TensorFlow（1）張量及基本函數

tensor

維數	階	名字	例子
0	0	標量（）	s = 1 2 3
1	1	向量（）	v = [1,2,3]
2	2	矩陣（）	m = [[1,2,3],[4,5,6],[7,8,9]]
n	n	張量（）	t = [[[[[[[[ n個「[」

tensorflow的數據類型

• tf.int,
• tf.float ……
• tf.int 32,
• tf.float 32,
• tf.float 64
• tf.bool
• tf.constant([True, False])
• tf.string
• tf.constant(「Hello, world!」)

建立一個張量（Tensor）

tf.constant(張量內容，dtype=數據類型(可選))

#建立一個張量（Tensor）
import tensorflow as tf

a = tf.constant([1, 5], dtype=tf.int64)
#建立1階張量，裏面兩個元素分別爲1,5
#指定數據類型爲64位整型

print("a:", a)
print("a.dtype:", a.dtype)
#打印出a的數據類型
print("a.shape:", a.shape)
#打印出a的形狀

a: tf.Tensor([1 5], shape=(2,), dtype=int64)
a.dtype: <dtype: 'int64'>
a.shape: (2,)

張量的形狀看shape=（2，）中的逗號隔開了幾個數字，上面示例中的逗號隔開了一個數字2，因此是1維張量，數字是2，說明這個張量裏有兩個元素，也就是上面的數值1和數值5

將numpy的數據類型轉換爲Tensor數據類型

tf. convert_to_tensor(數據名，dtype=數據類型(可選))

#將numpy的數據類型轉換爲Tensor數據類型
import tensorflow as tf
import numpy as np

a = np.arange(0, 5)
b = tf.convert_to_tensor(a, dtype=tf.int64)
#將numpy格式a變成了Tensor格式b

print("a:", a)
print("b:", b)

a: [0 1 2 3 4]
b: tf.Tensor([0 1 2 3 4], shape=(5,), dtype=int64)

建立全爲0的張量

tf. zeros(維度)

建立全爲1的張量

tf. ones(維度)

建立全爲指定值的張量

tf. fill(維度，指定值)

#建立全爲0，1，指定值的張量
import tensorflow as tf

a = tf.zeros([2, 3])
#建立一個2維張量，第一個維度有2個元素，第二個維度有3個元素，元素內容全是0

b = tf.ones(4)
#建立一個一維張量，裏面有4個元素，內容全是1

c = tf.fill([2, 2], 9)
#建立一個兩行兩列的二維張量，第一個維度有2個元素，第二個維度有2個元素，元素都是9

print("a:", a)
print("b:", b)
print("c:", c)

a: tf.Tensor(
[[0. 0. 0.]
 [0. 0. 0.]], shape=(2, 3), dtype=float32)
b: tf.Tensor([1. 1. 1. 1.], shape=(4,), dtype=float32)
c: tf.Tensor(
[[9 9]
 [9 9]], shape=(2, 2), dtype=int32)

維度：
一維 括號裏直接寫數字
二維 用 [行，列]
多維 用 [n,m,j,k……]，括號裏寫每一個維度的元素個數，中間用逗號隔開

建立隨機數組成的張量

生成正態分佈的隨機數，默認均值爲0，標準差爲1

tf. random.normal (維度，mean=均值，stddev=標準差)

生成截斷式正態分佈的隨機數，

tf. random.truncated_normal (維度，mean=均值，stddev=標準差)

在tf.truncated_normal中若是隨機生成數據的取值在（μ-2σ，μ+2σ）以外
則從新進行生成，保證了生成值在均值附近。μ：均值， σ：標準差

import tensorflow as tf

d = tf.random.normal([2, 2], mean=0.5, stddev=1)
#生成2行，2列的張量，裏面的元素符合以0.5爲均值，1爲標準差的正態分佈

print("d:", d)

e = tf.random.truncated_normal([2, 2], mean=0.5, stddev=1)
#生成2行，2列的張量，裏面的元素符合以0.5爲均值，1爲標準差的截斷式正態分佈，生成的元素在{均值±（2*標準差）}以內
#數據更向均值0.5集中

print("e:", e)

d: tf.Tensor(
[[0.78079236 0.36991078]
 [0.5447546  0.85526705]], shape=(2, 2), dtype=float32)
e: tf.Tensor(
[[-1.0678291  -0.20061862]
 [ 0.1491285   0.40372872]], shape=(2, 2), dtype=float32)

生成均勻分佈隨機數 [ minval, maxval )

tf. random. uniform(維度，minval=最小值，maxval=最大值)

#生成平均分佈的隨機數
import tensorflow as tf

f = tf.random.uniform([2, 2], minval=0, maxval=1)
#生成兩行兩列張量，，其中的每一個元素都符合在0~1之間的平均分佈

print("f:", f)

f: tf.Tensor(
[[0.13252604 0.0960362 ]
 [0.35313892 0.33435488]], shape=(2, 2), dtype=float32)

實現強制tensor轉換爲該數據類型

tf.cast (張量名，dtype=數據類型)

計算張量維度上元素的最小值

tf.reduce_min (張量名)

計算張量維度上元素的最大值

tf.reduce_max (張量名)

#給定張量，轉換張量的類型
#找出張量的最小值，最大值
import tensorflow as tf

x1 = tf.constant([1., 2., 3.], dtype=tf.float64)
#構建一個張量x1
print("x1:", x1)

x2 = tf.cast(x1, tf.int32)
#將x1變成32位整型
print("x2", x2)

print("minimum of x2：", tf.reduce_min(x2))
print("maxmum of x2:", tf.reduce_max(x2))
#打印x2的最小值，最大值

x1: tf.Tensor([1. 2. 3.], shape=(3,), dtype=float64)
x2 tf.Tensor([1 2 3], shape=(3,), dtype=int32)
minimum of x2： tf.Tensor(1, shape=(), dtype=int32)
maxmum of x2: tf.Tensor(3, shape=(), dtype=int32)

axis

在一個二維張量或數組中，能夠經過調整 axis 等於0或1 控制執行維度。

• axis=0表明跨行（經度，down)，
• axis=1表明跨列（緯度，across)
• 若是不指定axis，則全部元素參與計算。

計算張量沿着指定維度的平均值

tf.reduce_mean (張量名，axis=操做軸)

計算張量沿着指定維度的和

tf.reduce_sum (張量名，axis=操做軸)

#axis
import tensorflow as tf

x = tf.constant([[1, 2, 3], [2, 2, 3]])

print("x:", x)
print("mean of x:", tf.reduce_mean(x)) 
# 不指定axis，求x中全部數的均值
print("sum of x:", tf.reduce_sum(x, axis=1))  
# 沿橫向方向求每一行的和

x: tf.Tensor(
[[1 2 3]
 [2 2 3]], shape=(2, 3), dtype=int32)
mean of x: tf.Tensor(2, shape=(), dtype=int32)
sum of x: tf.Tensor([6 7], shape=(2,), dtype=int32)

tf.Variable ()將變量標記爲「可訓練」

被標記的變量會在反向傳播中記錄梯度信息。

神經網絡訓練中，經常使用該函數標記待訓練參數。

tf.Variable(初始值)

#神經網絡中初始化參數w的代碼以下
w = tf.Variable(tf.random.normal([2, 2], mean=0, stddev=1))
#首先隨機生成正態分佈隨機數，
#再給生成的隨機數標記爲可訓練，

tensorflow中的數學計算函數

對應元素的四則運算（只有維度相同的張量才能夠作四則運算）：加減乘除

tf.add，tf.subtract，tf.multiply，tf.divide

#實現兩個張量的對應元素相加
tf.add (張量1，張量2)
#實現兩個張量的對應元素相減
tf.subtract (張量1，張量2)
#實現兩個張量的對應元素相乘
tf.multiply (張量1，張量2)
#實現兩個張量的對應元素相除
tf.divide (張量1，張量2)

#張量之間的加減乘除
import tensorflow as tf

a = tf.ones([1, 3])
#建立一個1行3列的張量a，全部元素是1
b = tf.fill([1, 3], 3.)
#建立一個1行3列的張量2，全部元素是3

print("a:", a)
print("b:", b)
print("a+b:", tf.add(a, b))            #a和b對應元素相加
print("a-b:", tf.subtract(a, b))      #a和b對應元素相減
print("a*b:", tf.multiply(a, b))     #a和b對應元素相乘
print("b/a:", tf.divide(b, a))      #b中元素除以a

a: tf.Tensor([[1. 1. 1.]], shape=(1, 3), dtype=float32)
b: tf.Tensor([[3. 3. 3.]], shape=(1, 3), dtype=float32)
a+b: tf.Tensor([[4. 4. 4.]], shape=(1, 3), dtype=float32)
a-b: tf.Tensor([[-2. -2. -2.]], shape=(1, 3), dtype=float32)
a*b: tf.Tensor([[3. 3. 3.]], shape=(1, 3), dtype=float32)
b/a: tf.Tensor([[3. 3. 3.]], shape=(1, 3), dtype=float32)

平方，次方，開方

tf.square，tf.pow，tf.sqrt

#計算某個張量的平方
tf.square (張量名)
#計算某個張量的n次方
tf.pow (張量名，n次方數)
#計算某個張量的開方
tf.sqrt (張量名）

#張量次方，平方，開方操做
import tensorflow as tf

a = tf.fill([1, 2], 3.)    
#構建一個1行2列的二維張量，填充數值都是3
print("a:", a)
print("a的三次方:", tf.pow(a, 3))       #對a求三次方
print("a的平方:", tf.square(a))       #對a求平方
print("a的開方:", tf.sqrt(a))       #對a求開方

a: tf.Tensor([[3. 3.]], shape=(1, 2), dtype=float32)
a的三次方: tf.Tensor([[27. 27.]], shape=(1, 2), dtype=float32)
a的平方: tf.Tensor([[9. 9.]], shape=(1, 2), dtype=float32)
a的開方: tf.Tensor([[1.7320508 1.7320508]], shape=(1, 2), dtype=float32)

矩陣乘法：

tf.matmul

#實現兩個矩陣的相乘
tf.matmul(矩陣1，矩陣2)

#矩陣相乘
import tensorflow as tf

a = tf.ones([3, 2])         #3行2列全1矩陣a
b = tf.fill([2, 3], 3.)     #2行3列全3矩陣b
print("a:", a)
print("b:", b)
print("a*b:", tf.matmul(a, b))
#結果是3行3列全6矩陣

a: tf.Tensor(
[[1. 1.]
 [1. 1.]
 [1. 1.]], shape=(3, 2), dtype=float32)
b: tf.Tensor(
[[3. 3. 3.]
 [3. 3. 3.]], shape=(2, 3), dtype=float32)
a*b: tf.Tensor(
[[6. 6. 6.]
 [6. 6. 6.]
 [6. 6. 6.]], shape=(3, 3), dtype=float32)

tf.data.Dataset.from_tensor_slices將輸入特徵和標籤配對

神經網絡是將輸入特徵和標籤配對後再送入神經網絡的，

tf.data.Dataset.from_tensor_slices能夠實現將標籤和特徵進行配對，此函數對於numpy格式和tensor格式都適用

data = tf.data.Dataset.from_tensor_slices((輸入特徵, 標籤))

#輸入特徵和標籤配對
import tensorflow as tf

features = tf.constant([12, 23, 10, 17])
#收集的特徵是12,23,10,17
labels = tf.constant([0, 1, 1, 0])
#每一個特徵對應的標籤分別是0,1,1,0

dataset = tf.data.Dataset.from_tensor_slices((features, labels))
#使用tf.data.Dataset.from_tensor_slices()將特徵和標籤配上對

for element in dataset:     #分別打印每個dataset
    print(element)

(<tf.Tensor: shape=(), dtype=int32, numpy=12>, <tf.Tensor: shape=(), dtype=int32, numpy=0>)
(<tf.Tensor: shape=(), dtype=int32, numpy=23>, <tf.Tensor: shape=(), dtype=int32, numpy=1>)
(<tf.Tensor: shape=(), dtype=int32, numpy=10>, <tf.Tensor: shape=(), dtype=int32, numpy=1>)
(<tf.Tensor: shape=(), dtype=int32, numpy=17>, <tf.Tensor: shape=(), dtype=int32, numpy=0>)

在with結構中使用tf.GradientTape實現某個函數對指定參數的求導運算

配合上面的tf.Variable()函數能夠實現損失函數loss對參數w的求導運算

with tf.GradientTape( ) as tape:
	若干個計算過程
grad=tape.gradient(函數，對誰求導)

#求導運算
import tensorflow as tf

with tf.GradientTape() as tape:
    x = tf.Variable(tf.constant(3.0))    #將變量x設置爲可訓練的
    y = tf.pow(x, 2)                    #y=x^2
grad = tape.gradient(y, x)              #y對x求導，dy/dx=2*x,帶入x=3，dy/dx=6.0
print(grad)

tf.Tensor(6.0, shape=(), dtype=float32)

enumerate（枚舉）

enumerate是python的內建函數，它可遍歷每一個元素(如列表、元組或字符串)，組合爲：索引 元素，常在for循環中使用。

enumerate(列表名)

#枚舉
seq = ['one', 'two', 'three']   #新建列表賦值給seq
for i, element in enumerate(seq):
    #enumerate()括號裏面是列表名；
    #i接收索引號，element接收元素
    print(i, element)

0 one
1 two
2 three

獨熱碼

在實現分類問題時，常使用獨熱碼來表示標籤

• 1表示是對應元素
• 0表示不是對應元素

	（0）狗尾草鳶尾花	（1）雜色鳶尾花	（2）弗吉尼亞鳶尾花
標籤爲1對應的獨熱碼	0	1	0
獨熱碼錶示的意義	0%的可能表示狗尾草鳶尾	100%的可能表示雜色鳶尾	0%的可能表示弗吉尼亞鳶尾

tf.one_hot()函數將待轉換數據，轉換爲one-hot形式的數據輸出。

tf.one_hot (待轉換數據, depth=幾分類)

#獨熱碼轉換
import tensorflow as tf

classes = 3     #3分類
labels = tf.constant([1, 0, 2]) #待轉換的數據
#輸入的三個標籤分別是1,0,2
#輸入的元素值最小爲0，最大爲2
output = tf.one_hot(labels, depth=classes)
print("result of labels1:", output)
print("\n")

result of labels1: tf.Tensor(
[[0. 1. 0.]
 [1. 0. 0.]
 [0. 0. 1.]], shape=(3, 3), dtype=float32)

​

tf.nn.softmax，分類問題，將輸出結果轉化成符合機率分佈的機率

tf.nn.softmax使輸出符合機率分佈，也就是將不一樣的輸出轉化成相對應的機率，輸出的和爲1

tf.nn.softmax(x) 使輸出符合機率分佈

使n分類的n個輸出 （y0 ，y1, …… yn-1）經過softmax( ) 函數，符合機率分佈，也就是將每一個輸出值轉化成0到1之間的機率值，，而且這些機率的和是1

#將神經網絡前向傳播結果轉化成相對應的機率
import tensorflow as tf

y = tf.constant([1.01, 2.01, -0.66])    #將前向傳播結果1.01,2.01，-0.66組成張量y
y_pro = tf.nn.softmax(y)                #將相應的y送入softmax函數，轉化成相對應的機率

print("After softmax, y_pro is:", y_pro)           # y_pro 符合機率分佈
print("The sum of y_pro:", tf.reduce_sum(y_pro))  # 經過softmax後，全部機率加起來和爲1

After softmax, y_pro is: tf.Tensor([0.25598174 0.69583046 0.04818781], shape=(3,), dtype=float32)
The sum of y_pro: tf.Tensor(1.0, shape=(), dtype=float32)

assign_sub經常使用於參數的自更新，

調用assign_sub前，先用 tf.Variable 將等待更新的變量 w 爲可訓練（可自更新），才能夠實現自更新

w.assign_sub (w要自減的內容)

#自減，參數更新
import tensorflow as tf

x = tf.Variable(4)  #x先被定義爲variable類型，初始值是4
x.assign_sub(1)     #對x作自減操做，即x=x-1，自減的內容寫在括號裏，括號裏是1，則表示自減1
print("x:", x)  # 4-1=3

x: <tf.Variable 'Variable:0' shape=() dtype=int32, numpy=3>

tf.argmax返回張量沿指定維度最大值的索引，

注意返回的是索引號而不是值

tf.argmax (張量名,axis=操做軸)

import numpy as np
import tensorflow as tf

test = np.array([[1, 2, 3], [2, 3, 4], [5, 4, 3], [8, 7, 2]])     #2維張量test
print("test:\n", test)
print("每一列的最大值的索引號：", tf.argmax(test, axis=0))  # 返回縱向每一列最大值的索引號
print("每一行的最大值的索引號：", tf.argmax(test, axis=1))  # 返回橫向每一行最大值的索引號

test:
 [[1 2 3]
 [2 3 4]
 [5 4 3]
 [8 7 2]]
每一列的最大值的索引號： tf.Tensor([3 3 1], shape=(3,), dtype=int64)
每一行的最大值的索引號： tf.Tensor([2 2 0 0], shape=(4,), dtype=int64)

參考視頻及資料：https://www.bilibili.com/video/BV1B7411L7Qt?from=search&seid=202820015499098798