5個簡單的步驟掌握Tensorflow的Tensor

做者|Orhan G. Yalçın
編譯|VK
來源|Towards Datas Sciencepython

若是你正在讀這篇文章,我相信咱們有着類似的興趣,如今/未來也會從事相似的行業。算法

在這篇文章中,咱們將深刻研究Tensorflow Tensor的細節。咱們將在如下五個簡單步驟中介紹與Tensorflow的Tensor中相關的全部主題:數組

  • 第一步:張量的定義→什麼是張量?框架

  • 第二步:建立張量→建立張量對象的函數機器學習

  • 第三步:張量對象的特徵函數

  • 第四步:張量操做→索引、基本張量操做、形狀操做、廣播學習

  • 第五步:特殊張量測試

張量的定義:什麼是張量

張量是TensorFlow的均勻型多維數組。它們很是相似於NumPy數組,而且它們是不可變的,這意味着一旦建立它們就不能被更改。只能使用編輯建立新副本。this

讓咱們看看張量如何與代碼示例一塊兒工做。可是首先,要使用TensorFlow對象,咱們須要導入TensorFlow庫。咱們常常將NumPy與TensorFlow一塊兒使用,所以咱們還可使用如下行導入NumPy:spa

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數組索引。

關於索引的一些規則:

  1. 索引從零(0)開始。

  2. 負索引(「-n」)值表示從末尾向後計數。

  3. 冒號(「:」)用於切片:開始:中止:步驟。

  4. 逗號(「,」)用於達到更深層次。

讓咱們用如下幾行建立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

如今,咱們已經介紹了索引的基本知識,讓咱們看看咱們能夠對張量進行的基本操做。

張量基本運算

你能夠輕鬆地對張量進行基本的數學運算,例如:

  1. 加法

  2. 元素乘法

  3. 矩陣乘法

  4. 求最大值或最小值

  5. 找到Max元素的索引

  6. 計算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還支持不規則或特殊的張量類型,這些類型包括:

  1. 良莠不齊的張量

  2. 字符串張量

  3. 稀疏張量

讓咱們仔細看看每個都是什麼。

良莠不齊的張量

良莠不齊張量是沿着尺寸軸具備不一樣數量元素的張量

能夠構建不規則張量,以下所示

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框架的基本知識瞭解得更多了。

查看本教程系列的第1部分:https://link.medium.com/yJp16uPoqab

原文連接:https://towardsdatascience.com/mastering-tensorflow-tensors-in-5-easy-steps-35f21998bb86

歡迎關注磐創AI博客站:
http://panchuang.net/

sklearn機器學習中文官方文檔:
http://sklearn123.com/

歡迎關注磐創博客資源彙總站:
http://docs.panchuang.net/

相關文章
相關標籤/搜索