tensorflow之tf.tile\tf.slice等函數的基本用法解讀

tf.tile

解讀：
tensorflow中的tile()函數是用來對張量(Tensor)進行擴展的，其特點是對當前張量內的數據進行一定規則的複製。最終的輸出張量維度不變。

函數定義：

tf.tile(
    input,
    multiples,
    name=None)

input是待擴展的張量，multiples是擴展方法。
假如input是一個3維的張量。那麼mutiples就必須是一個1x3的1維張量。這個張量的三個值依次表示input的第1，第2，第3維數據擴展幾倍。
具體舉一個例子：

import tensorflow as tf

a = tf.constant([[1, 2], [3, 4], [5, 6]], dtype=tf.float32)
a1 = tf.tile(a, [2, 3])
with tf.Session() as sess:
    print(sess.run(a))
    print(sess.run(a1))

tf.tile()具體的操作過程如下：

請注意：上面繪圖中第一次擴展後第一維由三個數據變成兩行六個數據，多一行並不是多了一維，數據扔爲順序排列，只是爲了方便繪製而已。

每一維數據的擴展都是將前面的數據進行復制然後直接接在原數據後面。

如果multiples的某一個數據爲1，則表示該維數據保持不變。

示例：

import  tensorflow  as tf
def test12():
    a = tf.constant([[1, 2], [3, 4], [5, 6]], dtype=tf.float32)
    print(a)
    doc_y = tf.tile(a, [1, 1])
    print(doc_y)
    with tf.Session() as sess:
        print(sess.run(a))
        print(sess.run(doc_y))

[[ 1. 2.]
[ 3. 4.]
[ 5. 6.]]
[[ 1. 2.]
[ 3. 4.]
[ 5. 6.]]

tf.slice

tf.slice(input_, begin, size, name = None)
解釋 ：

這個函數的作用是從輸入數據input中提取出一塊切片
切片的尺寸是size，切片的開始位置是begin。
切片的尺寸size表示輸出tensor的數據維度，其中size[i]表示在第i維度上面的元素個數。
開始位置begin表示切片相對於輸入數據input_的每一個偏移量，比如數據input是

[[[1, 1, 1], [2, 2, 2]],
[[33, 3, 3], [4, 4, 4]],
[[5, 5, 5], [6, 6, 6]]]，

begin爲[1, 0, 0]，那麼數據的開始位置是33。因爲，第一維偏移了1，其餘幾位都沒有偏移，所以開始位置是33。
操作滿足：

size[i] = input.dim_size(i) - begin[i]
0 <= begin[i] <= begin[i] + size[i] <= Di for i in [0, n]

這裏解釋一下tf.slice()的作用和用法;

silce_1,此時切片的起點是[0,0,0],切片的大小是[1,1,3];於是從原點開始切一個[1,1,3]的數據，也就是一個批次的（1,3）

slice_2,此時切片的起點是[1,0,0],切片的大小是[1,2,3];意思就是從第二個批次的數據開始進行切片，切下一個批次的（2,3）的數據

slice_3,此時切片的起點仍然是[1,0,0],切片的大小是[2,1,3];就是從第二個批次開始，切一個兩個批次的（1,3）的數據

示例：
import tensorflow as tf

sess = tf.Session()
input = tf.constant([[[1, 1, 1], [2, 2, 2]],
                     [[3, 3, 3], [4, 4, 4]],
                     [[5, 5, 5], [6, 6, 6]]])

data = tf.slice(input, [1, 0, 0], [1, 1, 3])
print(sess.run(data))
"""[1,0,0]表示第一維偏移了1
則是從[[[3, 3, 3], [4, 4, 4]],[[5, 5, 5], [6, 6, 6]]]中選取數據
然後選取第一維的第一個，第二維的第一個數據，第三維的三個數據"""
# [[[3 3 3]]]
data = tf.slice(input, [1, 0, 0], [1, 2, 3])
print(sess.run(data))
# [[[3 3 3]
#   [4 4 4]]]
data = tf.slice(input, [1, 0, 0], [2, 1, 3])
print(sess.run(data))
# [[[3 3 3]]
#
#  [[5 5 5]]]
data = tf.slice(input, [1, 0, 0], [2, 2, 2])
print(sess.run(data))
# [[[3 3]
#   [4 4]]
#
#  [[5 5]
#   [6 6]]]
"""輸入參數：
  ● input_: 一個Tensor。
  ● begin: 一個Tensor，數據類型是int32或者int64。
  ● size: 一個Tensor，數據類型是int32或者int64。
  ● name:（可選）爲這個操作取一個名字。
輸出參數：
  ● 一個Tensor，數據類型和input_相同。"""

示例二：多應用與求概率

  prob = tf.constant([[1, 2], [3, 4], [5, 6]], dtype=tf.float32)
    hit_prob = tf.slice(prob, [0, 0], [-1, 1])
    sess = tf.Session()
    print(sess.run(hit_prob))

[[ 1.]
[ 3.]
[ 5.]]

tf.square()

tf.math.square(
    x,
    name=None
)

功能：計算元素x的平方

Args:

x: A Tensor or SparseTensor. Must be one of the following types: half, float32, float64, int32, int64, complex64, complex128.
name: A name for the operation (optional).

prob = tf.constant([[1, 2], [3, 4], [5, 6]], dtype=tf.float32)
sess = tf.Session()
print(sess.run(tf.square(prob)))

[[ 1. 4.]
[ 9. 16.]
[ 25. 36.]]

tf.reduce_sum

reduce_sum(input_tensor, axis=None, keepdims=False, name=None)

For example:

x = tf.constant([[1, 1, 1], [1, 1, 1]])
tf.reduce_sum(x)  # 6
tf.reduce_sum(x, 0)  # [2, 2, 2]
tf.reduce_sum(x, 1)  # [3, 3]
tf.reduce_sum(x, 1, keepdims=True)  # [[3], [3]]
tf.reduce_sum(x, [0, 1])  # 6

Args:
input_tensor: The tensor to reduce. Should have numeric type.
axis: The dimensions to reduce. If None (the default), reduces all
dimensions. Must be in the range [-rank(input_tensor), rank(input_tensor)).
keepdims: If true, retains reduced dimensions with length 1.
name: A name for the operation (optional).

Returns:
The reduced tensor, of the same dtype as the input_tensor.

tf.multiply（）

兩個矩陣中對應元素各自相乘
格式: tf.multiply(x, y, name=None)
參數:
x: 一個類型爲:half, float32, float64, uint8, int8, uint16, int16, int32, int64, complex64, complex128的張量。
y: 一個類型跟張量x相同的張量。
返回值： x * y element-wise.
注意：
（1）multiply這個函數實現的是元素級別的相乘，也就是兩個相乘的數元素各自相乘，而不是矩陣乘法，注意和tf.matmul區別。
（2）兩個相乘的數必須有相同的數據類型，不然就會報錯。

tf.matmul（）

將矩陣a乘以矩陣b，生成a * b。
格式: tf.matmul(a, b, transpose_a=False, transpose_b=False, adjoint_a=False, adjoint_b=False, a_is_sparse=False, b_is_sparse=False, name=None)
參數:
a: 一個類型爲 float16, float32, float64, int32, complex64, complex128 且張量秩 > 1 的張量。
b: 一個類型跟張量a相同的張量。
transpose_a: 如果爲真, a則在進行乘法計算前進行轉置。
transpose_b: 如果爲真, b則在進行乘法計算前進行轉置。
adjoint_a: 如果爲真, a則在進行乘法計算前進行共軛和轉置。
adjoint_b: 如果爲真, b則在進行乘法計算前進行共軛和轉置。
a_is_sparse: 如果爲真, a會被處理爲稀疏矩陣。
b_is_sparse: 如果爲真, b會被處理爲稀疏矩陣。
name: 操作的名字（可選參數）
返回值： 一個跟張量a和張量b類型一樣的張量且最內部矩陣是a和b中的相應矩陣的乘積。
注意：
（1）輸入必須是矩陣（或者是張量秩 >２的張量，表示成批的矩陣），並且其在轉置之後有相匹配的矩陣尺寸。
（2）兩個矩陣必須都是同樣的類型，支持的類型如下：float16, float32, float64, int32, complex64, complex128。
引發錯誤:
ValueError: 如果transpose_a 和 adjoint_a, 或 transpose_b 和 adjoint_b 都被設置爲真

tf.truediv

tf.truediv(
x,
y,
name=None
)

參數說明
x:張量。數值類型，作爲分子。

y: 張量。數值類型，作爲分母。

name:操作的名字，可選。

返回值:x/y,浮點型。