在這篇文章中，我們將深入研究Tensorflow Tensor的實現細節。我們將在以下五個簡單步驟中介紹與Tensorflow的Tensor中相關的所有主題：第一步：張量的定義→什么是張量？第二步：創建張量→創建張量對象的函數第三步：張量對象的特征第四步：張量操作→索引、基本張量操作、形狀操作、廣播第五步：特殊張量張量的定義：什么是張量？

張量是TensorFlow的均勻型多維數組，它非常類似于NumPy數組，并且是不可變的，這意味著一旦創建它們就不能被更改。首先，要使用TensorFlow對象，我們需要導入TensorFlow庫，因為我們經常將NumPy與TensorFlow一起使用，因此我們也可以導入NumPy：import tensorflow as tf

import numpy as np

張量的創建：創建張量對象有多種方法可以創建tf．Tensor對象，同時也可以使用多個TensorFlow函數來創建張量對象，如下例所示：＃ 你可以用｀tf．constant｀函數創建tf．Tensor對象：
x ＝ tf．constant（［［1， 2， 3， 4 ，5］］）
＃ 你可以用｀tf．ones｀函數創建tf．Tensor對象：
y ＝ tf．ones（（1，5））
＃ 你可以用｀tf．zeros｀函數創建tf．Tensor對象：
z ＝ tf．zeros（（1，5））
＃ 你可以用｀tf．range｀函數創建tf．Tensor對象：
q ＝ tf．range（start＝1， limit＝6， delta＝1）
print（x）
print（y）
print（z）
print（q）
輸出：
tf．Tensor（［［1 2 3 4 5］］， shape＝（1， 5）， dtype＝int32）
tf．Tensor（［［1． 1． 1． 1． 1．］］， shape＝（1， 5）， dtype＝float32）
tf．Tensor（［［0． 0． 0． 0． 0．］］， shape＝（1， 5）， dtype＝float32）
tf．Tensor（［1 2 3 4 5］， shape＝（5，）， dtype＝int32）

如你所見，我們使用三個不同的函數創建了形狀（1，5）的張量對象，使用tf．range（）函數創建了形狀（5，）的第四個張量對象。注意，tf．ones的和tf．zeros接受形狀作為必需的參數，因為它們的元素值是預先確定的。張量對象的特征tf．Tensor創建對象有幾個特征。首先，他們有維度數量；其次，它們有一個形狀，一個由維度的長度組成的列表；所有張量都有一個大小，即張量中元素的總數；最后，它們的元素都被記錄在一個統一的數據類型（datatype）中。讓我們仔細看看這些特征。維度張量根據其維數進行分類：Rank－0（標量）張量：包含單個值且沒有軸的張量（0維）；Rank－1張量：包含單軸（一維）值列表的張量；Rank－2張量：包含2個軸（2維）的張量；以及Rank－N張量：包含N軸的張量（三維）。

例如，我們可以通過向tf．constant傳遞一個三層嵌套的list對象來創建一個Rank－3張量。我們可以將數字分割成一個3層嵌套的列表，每個層有3個元素：three＿level＿nested＿list ＝ ［［［0， 1， 2］，
［3， 4， 5］］，
［［6， 7， 8］，
［9， 10， 11］］ ］
rank＿3＿tensor ＝ tf．constant（three＿level＿nested＿list）
print（rank＿3＿tensor）
Output：
tf．Tensor（ ［［［ 0 1 2］
［ 3 4 5］］

［［ 6 7 8］
［ 9 10 11］］］，
shape＝（2， 2， 3）， dtype＝int32）

我們可以查看“rank＿3＿tensor”對象當前具有“．ndim”屬性的維度數。tensor＿ndim ＝ rank＿3＿tensor．ndim
print（＂The number of dimensions in our Tensor object is＂， tensor＿ndim）
Output：
The number of dimensions in our Tensor object is 3

形狀形狀特征是每個張量都具有的另一個屬性，它以列表的形式顯示每個維度的大小。我們可以查看使用．shape屬性創建的rank＿3＿tensor對象的形狀，如下所示：tensor＿shape ＝ rank＿3＿tensor．shape
print（＂The shape of our Tensor object is＂， tensor＿shape）
Output：
The shape of our Tensor object is （2， 2， 3）

如你所見，我們的張量在第一層有兩個元素，第二層有兩個元素，第三層有三個元素。大小大小是張量的另一個特征，它表示張量有多少個元素。我們不能用張量對象的屬性來測量大小，相反，我們需要使用tf．size函數。最后，我們將使用實例函數．NumPy（）將輸出轉換為NumPy，以獲得更具可讀性的結果：tensor＿size ＝ tf．size（rank＿3＿tensor）．numpy（）
print（＂The size of our Tensor object is＂， tensor＿size）
Output：
The size of our Tensor object is 12

數據類型張量通常包含數字數據類型，如浮點和整數，但也可能包含許多其他數據類型，如復數和字符串。但是，每個張量對象必須將其所有元素存儲在一個統一的數據類型中，因此，我們還可以使用．dtype屬性查看為特定張量對象選擇的數據類型，如下所示：tensor＿dtype ＝ rank＿3＿tensor．dtype
print（＂The data type selected for this Tensor object is＂， tensor＿dtype）
Output：
The data type selected for this Tensor object is ＜dtype： ＇int32＇＞

張量運算索引索引是項目在序列中位置的數字表示，這個序列可以引用很多東西：一個列表、一個字符串或任意的值序列。TensorFlow還遵循標準的Python索引規則，這類似于列表索引或NumPy數組索引。關于索引的一些規則：索引從零（0）開始。負索引（“－n”）值表示從末尾向后計數。冒號（“：”）用于切片。逗號（“，”）用于進入更深的維度。讓我們用以下幾行創建rank＿1＿tensor：single＿level＿nested＿list ＝ ［0， 1， 2， 3， 4， 5， 6， 7， 8， 9， 10， 11］
rank＿1＿tensor ＝ tf．constant（single＿level＿nested＿list）
print（rank＿1＿tensor）
Output：
tf．Tensor（［ 0 1 2 3 4 5 6 7 8 9 10 11］，
shape＝（12，）， dtype＝int32）

測試一下我們的規則1，2，3：＃ 規則1，索引從0開始
print（＂First element is：＂，
rank＿1＿tensor［0］．numpy（））
＃ 規則2，負索引
print（＂Last element is：＂，
rank＿1＿tensor［－1］．numpy（））
＃ 規則3，切片
print（＂Elements in between the 1st and the last are：＂，
rank＿1＿tensor［1：－1］．numpy（））
Output：
First element is： 0
Last element is： 11
Elements in between the 1st and the last are： ［ 1 2 3 4 5 6 7 8 9 10］

現在，讓我們用以下代碼創建rank＿2＿tensor：two＿level＿nested＿list ＝ ［ ［0， 1， 2， 3， 4， 5］， ［6， 7， 8， 9， 10， 11］ ］
rank＿2＿tensor ＝ tf．constant（two＿level＿nested＿list）
print（rank＿2＿tensor）
Output：
tf．Tensor（ ［［ 0 1 2 3 4 5］
［ 6 7 8 9 10 11］］， shape＝（2， 6）， dtype＝int32）

用幾個例子來測試第4條規則：print（＂The 1st element of the first level is：＂，
rank＿2＿tensor［0］．numpy（））
print（＂The 2nd element of the first level is：＂，
rank＿2＿tensor［1］．numpy（））
＃ 規則4， 逗號用于進入更深的維度
print（＂The 1st element of the second level is：＂，
rank＿2＿tensor［0， 0］．numpy（））
print（＂The 3rd element of the second level is：＂，
rank＿2＿tensor［0， 2］．numpy（））
Output：
The first element of the first level is： ［0 1 2 3 4 5］
The second element of the first level is： ［ 6 7 8 9 10 11］
The first element of the second level is： 0
The third element of the second level is： 2

現在，我們已經介紹了索引的基本知識，讓我們看看我們可以對張量進行的基本操作。張量基本運算你可以輕松地對張量進行基本的數學運算，例如：加法元素乘法矩陣乘法求最大值或最小值找到Max元素的索引計算Softmax值讓我們看看這些運算，我們將創建兩個張量對象并應用這些操作。a ＝ tf．constant（［［2， 4］，
［6， 8］］， dtype＝tf．float32）
b ＝ tf．constant（［［1， 3］，
［5， 7］］， dtype＝tf．float32）

我們可以從加法開始。＃ 我們可以使用＇ tf．add（） ＇函數并將張量作為參數傳遞。
add＿tensors ＝ tf．add（a，b）
print（add＿tensors）
Output：
tf．Tensor（ ［［ 3． 7．］
［11． 15．］］， shape＝（2， 2）， dtype＝float32）

乘法＃ 我們可以使用＇ tf．multiply（） ＇函數并將張量作為參數傳遞。
multiply＿tensors ＝ tf．multiply（a，b）
print（multiply＿tensors）
Output：
tf．Tensor（ ［［ 2． 12．］
［30． 56．］］， shape＝（2， 2）， dtype＝float32）
矩陣乘法：＃ 我們可以使用＇ tf．matmul（） ＇函數并將張量作為參數傳遞。
matmul＿tensors ＝ tf．matmul（a，b）
print（matmul＿tensors）
Output：
tf．Tensor（ ［［ 2． 12．］
［30． 56．］］， shape＝（2， 2）， dtype＝float32）

注意：Matmul操作是深度學習算法的核心，因此，盡管你不會直接使用matmul，但了解這些操作是至關重要的。我們上面列出的其他操作示例：＃ 使用＇ tf．reduce＿max（） ＇和＇ tf．reduce＿min（） ＇函數可以找到最大值或最小值
print（＂The Max value of the tensor object b is：＂，
tf．reduce＿max（b）．numpy（））

＃ 使用＇ tf．argmax（） ＇函數可以找到最大元素的索引
print（＂The index position of the max element of the tensor object b is：＂，
tf．argmax（b）．numpy（））

＃ 使用 tf．nn．softmax＇函數計算softmax
print（＂The softmax computation result of the tensor object b is：＂，
tf．nn．softmax（b）．numpy（））
Output：
The Max value of the tensor object b is： 1．0
The index position of the Max of the tensor object b is： ［1 1］
The softmax computation result of the tensor object b is： ［［0．11920291 0．880797 ］ ［0．11920291 0．880797 ］］

操縱形狀就像在NumPy數組和pandas數據幀中一樣，你也可以重塑張量對象。這個變形操作非常快，因為底層數據不需要復制。對于重塑操作，我們可以使用tf．reshape函數＃ 我們的初始張量
a ＝ tf．constant（［［1， 2， 3， 4， 5， 6］］）
print（＇The shape of the initial Tensor object is：＇， a．shape）
b ＝ tf．reshape（a， ［6， 1］）
print（＇The shape of the first reshaped Tensor object is：＇， b．shape）
c ＝ tf．reshape（a， ［3， 2］）
print（＇The shape of the second reshaped Tensor object is：＇， c．shape）

＃ 如果我們以shape參數傳遞－1，那么張量就變平坦化。
print（＇The shape of the flattened Tensor object is：＇， tf．reshape（a， ［－1］））
Output：
The shape of our initial Tensor object is： （1， 6）
The shape of our initial Tensor object is： （6， 1）
The shape of our initial Tensor object is： （3， 2）
The shape of our flattened Tensor object is： tf．Tensor（［1 2 3 4 5 6］， shape＝（6，）， dtype＝int32）

如你所見，我們可以很容易地重塑我們的張量對象，但要注意的是，在進行重塑操作時，開發人員的操作必須是合理的，否則，張量可能會混淆，甚至會產生錯誤。廣播當我們嘗試使用多個張量對象進行組合操作時，較小的張量可以自動伸展以適應較大的張量，就像NumPy數組一樣。例如，當你嘗試將標量張量與秩2張量相乘時，標量將被拉伸以乘以每個秩2張量元素。參見以下示例：m ＝ tf．constant（［5］）
n ＝ tf．constant（［［1，2］，［3，4］］）
print（tf．multiply（m， n））
Output：
tf．Tensor（ ［［ 5 10］
［15 20］］， shape＝（2， 2）， dtype＝int32）

由于廣播操作，在對張量進行數學運算時，我們不必擔心大小匹配。張量的特殊類型我們常常會生成矩形張量，并將數值存儲為元素，但是，TensorFlow還支持不規則或特殊的張量類型，這些類型包括：參差不齊的張量字符串張量稀疏張量

讓我們仔細看看每一個都是什么。參差不齊的張量參差不齊張量是沿著尺寸軸具有不同數量元素的張量可以構建不規則張量，如下所示ragged＿list ＝ ［［1， 2， 3］，［4， 5］，［6］］
ragged＿tensor ＝ tf．ragged．constant（ragged＿list）
print（ragged＿tensor）
Output：
＜tf．RaggedTensor ［［1， 2， 3］，
［4， 5］，
［6］］＞

字符串張量字符串張量是存儲字符串對象的張量。我們可以建立一個字符串張量，就像你創建一個普通的張量對象一樣，但是，我們將字符串對象作為元素而不是數字對象傳遞，如下所示：string＿tensor ＝ tf．constant（［＂With this＂，
＂code， I am＂，
＂creating a String Tensor＂］）
print（string＿tensor）
Output：
tf．Tensor（［b＇With this＇
b＇code， I am＇
b＇creating a String Tensor＇］，
shape＝（3，）， dtype＝string）

稀疏張量最后，稀疏張量是稀疏數據的矩形張量。當數據中有空值時，稀疏張量就是對象。創建稀疏張量有點耗時，這里有一個例子：sparse＿tensor ＝ tf．sparse．SparseTensor（indices＝［［0， 0］， ［2， 2］， ［4， 4］］，
values＝［25， 50， 100］，
dense＿shape＝［5， 5］）

＃ 我們可以把稀疏張量轉換成密集張量
print（tf．sparse．to＿dense（sparse＿tensor））
Output：
tf．Tensor（ ［［ 25 0 0 0 0］
［ 0 0 0 0 0］
［ 0 0 50 0 0］
［ 0 0 0 0 0］
［ 0 0 0 0 100］］， shape＝（5， 5）， dtype＝int32）

結尾本文我們介紹了TensorFlow的張量對象的基礎知識。這應該會讓你對TensorFlow框架的基本知識了解得更多了。

審核編輯：符乾江