作者:chen_h
微訊號 & QQ:862251340
微信公眾號:coderpai
我的部落格:請點選這裡
計劃現將 tensorflow 中的 Python API 做一個學習,這樣方便以後的學習。
原文連結
減少元素操作
TensorFlow提供了一些操作,你可以用它來執行常見的數學運算,以此減少張量的維度。
tf.reduce_sum(input_tensor, reduction_indices=None, keep_dims=False, name=None)
解釋:這個函式的作用是計算指定維度的元素總和。
沿著給定的reduction_indices
維度,累加input_tensor
中該維度的元素,最後返回累加的值。如果keep_dims = False
,沿著reduction_indices
維度進行累加,最後返回一個秩為1的tensor
。如果keep_dims = True
,那麼每一維度的累加值返回一個秩為1的tensor
。
如果reduction_indices
沒有給定,那麼我們將input_tensor
中的元素全部進行累加,最後返回一個標量。
比如:
# `x` is [[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, keep_dims=True) ==> [[3], [3]]
tf.reduce_sum(x, [0, 1]) ==> 6複製程式碼
使用例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
a = tf.constant(np.random.rand(3,4))
c = tf.reduce_sum(a, 1, keep_dims = True)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼
輸入引數:
* input_tensor
: 一個累加的Tensor
,它應該是數字型別。
* reduction_indices
: 指定累加的維度。如果是None
,那麼累加所有的元素。
* keep_dims
: 如果是True
,那麼指定維度中的元素累加返回一個秩為1的Tensor
。如果是False
,那麼返回一個累加的標量。
* name
:(可選)為這個操作取一個名字。
輸出引數:
* 一個累加的Tensor
。
tf.reduce_prod(input_tensor, reduction_indices=None, keep_dims=False, name=None)
解釋:這個函式的作用是計算指定維度的元素相乘的總和。
沿著給定的reduction_indices
維度,累乘input_tensor
中該維度的元素,最後返回累乘的值。如果keep_dims = False
,沿著reduction_indices
維度進行累乘,最後返回一個秩為1的tensor
。如果keep_dims = True
,那麼每一維度的累乘值返回一個秩為1的tensor
。
如果reduction_indices
沒有給定,那麼我們將input_tensor
中的元素全部進行累乘,最後返回一個標量。
使用例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
a = tf.constant([[2,3,1],[4,5,1]])
c = tf.reduce_prod(a, 0)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼
輸入引數:
* input_tensor
: 一個累乘的Tensor
,它應該是數字型別。
* reduction_indices
: 指定累乘的維度。如果是None
,那麼累乘所有的元素。
* keep_dims
: 如果是True
,那麼指定維度中的元素累乘返回一個秩為1的Tensor
。如果是False
,那麼返回一個累乘的標量。
* name
:(可選)為這個操作取一個名字。
輸出引數:
* 一個累乘的Tensor
。
tf.reduce_min(input_tensor, reduction_indices=None, keep_dims=False, name=None)
解釋:這個函式的作用是計算指定維度的元素中的最小值。
沿著給定的reduction_indices
維度,找到input_tensor
中該維度的元素的最小值,最後返回這個最小值。如果keep_dims = False
,沿著reduction_indices
維度尋找最小值,最後返回一個秩為1的tensor
。如果keep_dims = True
,那麼每一維度的最小值返回一個秩為1的tensor
。
如果reduction_indices
沒有給定,那麼我們取input_tensor
中的最小元素,最後返回一個標量。
使用例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
a = tf.constant([[2,3,2],[4,5,1]])
c = tf.reduce_min(a, 0)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼
輸入引數:
* input_tensor
: 一個需要處理的Tensor
,它應該是數字型別。
* reduction_indices
: 指定需要查詢最小值的維度。如果是None
,那麼從所有的元素中找最小值。
* keep_dims
: 如果是True
,那麼指定維度中的最小值返回一個秩為1的Tensor
。如果是False
,那麼返回一個最小值的標量。
* name
:(可選)為這個操作取一個名字。
輸出引數:
* 一個處理之後的Tensor
。
tf.reduce_max(input_tensor, reduction_indices=None, keep_dims=False, name=None)
解釋:這個函式的作用是計算指定維度的元素中的最大值。
沿著給定的reduction_indices
維度,找到input_tensor
中該維度的元素的最大值,最後返回這個最大值。如果keep_dims = False
,沿著reduction_indices
維度尋找最大值,最後返回一個秩為1的tensor
。如果keep_dims = True
,那麼每一維度的最大值返回一個秩為1的tensor
。
如果reduction_indices
沒有給定,那麼我們取input_tensor
中的最大元素,最後返回一個標量。
使用例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
a = tf.constant([[2,3,2],[4,5,1]])
c = tf.reduce_max(a, 0)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼
輸入引數:
* input_tensor
: 一個需要處理的Tensor
,它應該是數字型別。
* reduction_indices
: 指定需要查詢最大值的維度。如果是None
,那麼從所有的元素中找最大值。
* keep_dims
: 如果是True
,那麼指定維度中的最大值返回一個秩為1的Tensor
。如果是False
,那麼返回一個最大值的標量。
* name
:(可選)為這個操作取一個名字。
輸出引數:
* 一個處理之後的Tensor
。
tf.reduce_mean(input_tensor, reduction_indices=None, keep_dims=False, name=None)
解釋:這個函式的作用是計算指定維度中的元素的平均值。
沿著給定的reduction_indices
維度,找到input_tensor
中該維度的元素的平均值,最後返回這個平均值。如果keep_dims = False
,沿著reduction_indices
維度尋找平均值,最後返回一個秩為1的tensor
。如果keep_dims = True
,那麼每一維度的平均值返回一個秩為1的tensor
。
如果reduction_indices
沒有給定,那麼我們取input_tensor
中的平均值,最後返回一個標量。
比如:
# `x` is [[1., 1. ]]
# [2., 2.]]
tf.reduce_mean(x) ==> 1.5
tf.reduce_mean(x, 0) ==> [1.5, 1.5]
tf.reduce_mean(x, 1) ==> [1., 2.]複製程式碼
使用例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
a = tf.constant([[2,3,2],[4,5,1]], tf.float32)
c = tf.reduce_mean(a, 0)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼
輸入引數:
* input_tensor
: 一個需要處理的Tensor
,它應該是數字型別。
* reduction_indices
: 指定需要查詢平均值的維度。如果是None
,那麼從所有的元素中找平均值。
* keep_dims
: 如果是True
,那麼指定維度中的平均值返回一個秩為1的Tensor
。如果是False
,那麼返回一個平均值的標量。
* name
:(可選)為這個操作取一個名字。
輸出引數:
* 一個處理之後的Tensor
。
tf.reduce_all(input_tensor, reduction_indices=None, keep_dims=False, name=None)
解釋:這個函式的作用是計算指定維度中的元素的邏輯與。
沿著給定的reduction_indices
維度,找到input_tensor
中該維度的元素的邏輯與,最後返回這個邏輯與值。如果keep_dims = False
,沿著reduction_indices
維度尋找邏輯與值,最後返回一個秩為1的tensor
。如果keep_dims = True
,那麼每一維度的邏輯與值返回一個秩為1的tensor
。
如果reduction_indices
沒有給定,那麼我們取input_tensor
中的邏輯與值,最後返回一個標量。
比如:
# `x` is [[True, True]]
# [False, False]]
tf.reduce_all(x) ==> False
tf.reduce_all(x, 0) ==> [False, False]
tf.reduce_all(x, 1) ==> [True, False]
複製程式碼
使用例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
a = tf.constant([[False, False,True],[False,True,True]])
c = tf.reduce_all(a, 0)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼
輸入引數:
* input_tensor
: 一個需要處理的Tensor
,它應該是數字型別。
* reduction_indices
: 指定需要查詢邏輯與值的維度。如果是None
,那麼從所有的元素中找邏輯與值。
* keep_dims
: 如果是True
,那麼指定維度中的邏輯與值返回一個秩為1的Tensor
。如果是False
,那麼返回一個邏輯與值的標量。
* name
:(可選)為這個操作取一個名字。
輸出引數:
* 一個處理之後的Tensor
。
tf.reduce_any(input_tensor, reduction_indices=None, keep_dims=False, name=None)
解釋:這個函式的作用是計算指定維度中的元素的邏輯或。
沿著給定的reduction_indices
維度,找到input_tensor
中該維度的元素的邏輯或,最後返回這個邏輯或值。如果keep_dims = False
,沿著reduction_indices
維度尋找邏輯或值,最後返回一個秩為1的tensor
。如果keep_dims = True
,那麼每一維度的邏輯或值返回一個秩為1的tensor
。
如果reduction_indices
沒有給定,那麼我們取input_tensor
中的邏輯或值,最後返回一個標量。
比如:
# `x` is [[True, True]]
# [False, False]]
tf.reduce_all(x) ==> False
tf.reduce_all(x, 0) ==> [True, True]
tf.reduce_all(x, 1) ==> [True, False]
複製程式碼
使用例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
a = tf.constant([[False, False,True],[False,True,True]])
c = tf.reduce_any(a, 0)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼
輸入引數:
* input_tensor
: 一個需要處理的Tensor
,它應該是數字型別。
* reduction_indices
: 指定需要查詢邏輯或值的維度。如果是None
,那麼從所有的元素中找邏輯或值。
* keep_dims
: 如果是True
,那麼指定維度中的邏輯或值返回一個秩為1的Tensor
。如果是False
,那麼返回一個邏輯或值的標量。
* name
:(可選)為這個操作取一個名字。
輸出引數:
* 一個處理之後的Tensor
。
tf.accumulate_n(inputs, shape=None, tensor_dtype=None, name=None)
解釋:這個函式的作用是計算張量列表中每個對應的元素的累加和。
其中,shape
和tensor_dtype
是可選項,主要是為了驗證最後返回的累加值的資料維度和資料型別是否和猜測的一樣,如果不一樣,將會報錯。
比如:
# tensor `a` is [[1, 2], [3, 4]
# tensor `b` is [[5, 0], [0, 6]]
tf.accumulate_n([a, b, a]) ==> [[7, 4], [6, 14]]
# Explicitly pass shape and type
tf.accumulate_n([a, b, a], shape=[2, 2], tensor_dtype=tf.int32)
==> [[7, 4], [6, 14]]複製程式碼
使用例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
a = tf.constant([[1, 2], [3, 4]])
b = tf.constant([[5, 0], [0, 6]])
c = tf.accumulate_n([a,b,a], shape = [2,2])
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼
輸入引數:
* inputs
: 一個需要處理的Tensor
列表,其中每一個tensor
都必須擁有相同的資料維度和資料型別。
* shape
: inputs
的資料維度。
* tensor_dtype
: inputs
的資料型別。
* name
:(可選)為這個操作取一個名字。
輸出引數:
* 一個Tensor
,資料維度和資料型別都和inputs
相同。
異常:
* 如果inputs
中每一個tensor
的資料維度不一樣,或者推測的資料維度或資料型別不正確,那麼都會丟擲異常。
分割操作
TensorFlow提供了一些操作,你可以使用基本的算術運算來分割輸入的tensor
。這裡的分割操作是沿著第一個維度的一個分割槽,等價於這裡定義了一個從第一個維度到第segment_ids
維度的一個對映。segment_ids
張量的長度必須和需要分割的tensor
的第一維度的尺寸d0
一樣,其中segment_ids
中的編號從0
到k
,並且k < d0
。舉個例子,如果我們需要分割的tensor
是一個矩陣,那麼segment_ids
的對映就指向矩陣的每一行。
比如:
c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])
tf.segment_sum(c, tf.constant([0, 0, 1]))
==> [[0 0 0 0]
[5 6 7 8]]複製程式碼
tf.segment_sum(data, segment_ids, name=None)
解釋:這個函式的作用是沿著segment_ids
指定的維度,分割張量data
中的值,並且返回累加值。
計算公式為:
其中,segment_ids[j] == i
。
使用例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
a = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8], [-1,-2,-3,-4]])
c = tf.segment_sum(a, tf.constant([0, 0, 1, 2]))
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼
輸入引數:
* data
: 一個Tensor
,資料型別必須是以下之一:float32
,float64
,int32
,int64
,uint8
,int16
,int8
。
* segment_ids
: 一個tensor
,資料型別必須是int32
或者int64
,資料維度是一維的,並且長度和data
第一維度的長度相同。裡面的值是從0
到k
的有序排列,但是可以重複。
* name
:(可選)為這個操作取一個名字。
輸出引數:
* 一個Tensor
,資料型別和data
相同,資料的第一維度是k
,其餘維度和data
相同。
tf.segment_prod(data, segment_ids, name=None)
解釋:這個函式的作用是沿著segment_ids
指定的維度,分割張量data
中的值,並且返回累乘值。
計算公式為:
其中,segment_ids[j] == i
。
使用例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
a = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8], [-1,-2,-3,-4]])
c = tf.segment_prod(a, tf.constant([0, 0, 1, 2]))
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼
輸入引數:
* data
: 一個Tensor
,資料型別必須是以下之一:float32
,float64
,int32
,int64
,uint8
,int16
,int8
。
* segment_ids
: 一個tensor
,資料型別必須是int32
或者int64
,資料維度是一維的,並且長度和data
第一維度的長度相同。裡面的值是從0
到k
的有序排列,但是可以重複。
* name
:(可選)為這個操作取一個名字。
輸出引數:
* 一個Tensor
,資料型別和data
相同,資料的第一維度是k
,其餘維度和data
相同。
tf.segment_min(data, segment_ids, name=None)
解釋:這個函式的作用是沿著segment_ids
指定的維度,分割張量data
中的值,並且返回最小值。
計算公式為:
其中,segment_ids[j] == i
。
使用例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
a = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8], [-1,-2,-3,-4]])
c = tf.segment_min(a, tf.constant([0, 0, 1, 2]))
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼
輸入引數:
* data
: 一個Tensor
,資料型別必須是以下之一:float32
,float64
,int32
,int64
,uint8
,int16
,int8
。
* segment_ids
: 一個tensor
,資料型別必須是int32
或者int64
,資料維度是一維的,並且長度和data
第一維度的長度相同。裡面的值是從0
到k
的有序排列,但是可以重複。
* name
:(可選)為這個操作取一個名字。
輸出引數:
* 一個Tensor
,資料型別和data
相同,資料的第一維度是k
,其餘維度和data
相同。
tf.segment_max(data, segment_ids, name=None)
解釋:這個函式的作用是沿著segment_ids
指定的維度,分割張量data
中的值,並且返回最大值。
計算公式為:
其中,segment_ids[j] == i
。
使用例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
a = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8], [-1,-2,-3,-4]])
c = tf.segment_max(a, tf.constant([0, 0, 1, 2]))
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼
輸入引數:
* data
: 一個Tensor
,資料型別必須是以下之一:float32
,float64
,int32
,int64
,uint8
,int16
,int8
。
* segment_ids
: 一個tensor
,資料型別必須是int32
或者int64
,資料維度是一維的,並且長度和data
第一維度的長度相同。裡面的值是從0
到k
的有序排列,但是可以重複。
* name
:(可選)為這個操作取一個名字。
輸出引數:
* 一個Tensor
,資料型別和data
相同,資料的第一維度是k
,其餘維度和data
相同。
tf.segment_mean(data, segment_ids, name=None)
解釋:這個函式的作用是沿著segment_ids
指定的維度,分割張量data
中的值,並且返回平均值。
計算公式為:
其中,segment_ids[j] == i
。
使用例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
a = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8], [-1,-2,-3,-4]])
c = tf.segment_mean(a, tf.constant([0, 0, 1, 2]))
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼
輸入引數:
* data
: 一個Tensor
,資料型別必須是以下之一:float32
,float64
,int32
,int64
,uint8
,int16
,int8
。
* segment_ids
: 一個tensor
,資料型別必須是int32
或者int64
,資料維度是一維的,並且長度和data
第一維度的長度相同。裡面的值是從0
到k
的有序排列,但是可以重複。
* name
:(可選)為這個操作取一個名字。
輸出引數:
* 一個Tensor
,資料型別和data
相同,資料的第一維度是k
,其餘維度和data
相同。
tf.unsorted_segment_sum(data, segment_ids, num_segments, name=None)
解釋:這個函式的作用是沿著segment_ids
指定的維度,分割張量data
中的值,並且返回累加值。
計算公式為:
其中,segment_ids[j] == i
。這個API和SegmentSum
最大的區別是,這個API不需要從0
到k
有序排列,可以亂序排列,並且該API不需要包含從0
到k
。
如果對於給定的分割區間ID i
,output[i] = 0
。那麼,num_segmetns
應該等於不同的段ID
的數量。
使用例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
a = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8], [-1,-2,-3,-4]])
c = tf.unsorted_segment_sum(a, tf.constant([0, 0, 1, 1]), 2)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼
輸入引數:
* data
: 一個Tensor
,資料型別必須是以下之一:float32
,float64
,int32
,int64
,uint8
,int16
,int8
。
* segment_ids
: 一個tensor
,資料型別必須是int32
或者int64
,資料維度是一維的,並且長度和data
第一維度的長度相同。
* num_segments
: 一個tensor
,資料型別是int32
。
* name
:(可選)為這個操作取一個名字。
輸出引數:
* 一個Tensor
,資料型別和data
相同,資料的第一維度是num_segments
,其餘維度和data
相同。
tf.sparse_segment_sum(data, indices, segment_ids, name=None)
解釋:這個函式的作用是沿著segment_ids
指定的維度,分割張量data
中的值,並且返回累加值。
該API和SegmentSum
差不多,但是該API的segment_ids
的長度可以小於data
的第一維度的長度,而是從indices
中選擇出需要切分的分割索引。
比如:
c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])
# Select two rows, one segment.
tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))
==> [[0 0 0 0]]
# Select two rows, two segment.
tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))
==> [[ 1 2 3 4]
[-1 -2 -3 -4]]
# Select all rows, two segments.
tf.sparse_segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))
==> [[0 0 0 0]
[5 6 7 8]]
# Which is equivalent to:
tf.segment_sum(c, tf.constant([0, 0, 1]))複製程式碼
使用例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
a = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8], [-1,-2,-3,-4]])
c = tf.sparse_segment_sum(a, tf.constant([0, 1, 1, 2]), tf.constant([0, 0, 1, 2]))
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼
輸入引數:
* data
: 一個Tensor
,資料型別必須是以下之一:float32
,float64
,int32
,int64
,uint8
,int16
,int8
。
* indices
: 一個tensor
,資料型別是int32
,資料維度是一維的,長度和segment_ids
相同。
* segment_ids
: 一個tensor
,資料型別必須是int32
,資料維度是一維的。裡面的值是有序排列的,但是可以重複。
name
:(可選)為這個操作取一個名字。
輸出引數:
* 一個Tensor
,資料型別和data
相同,資料的第一維度是k
,其餘維度和data
相同。
tf.sparse_segment_mean(data, indices, segment_ids, name=None)
解釋:這個函式的作用是沿著segment_ids
指定的維度,分割張量data
中的值,並且返回累加值。
該API和SegmentSum
差不多,但是該API的segment_ids
的長度可以小於data
的第一維度的長度,而是從indices
中選擇出需要切分的分割索引。
使用例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
a = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8], [-1,-2,-3,-4]], tf.float32)
c = tf.sparse_segment_mean(a, tf.constant([0, 1, 1, 2]), tf.constant([0, 0, 1, 2]))
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼
輸入引數:
* data
: 一個Tensor
,資料型別必須是以下之一:float32
,float64
。
* indices
: 一個tensor
,資料型別是int32
,資料維度是一維的,長度和segment_ids
相同。
* segment_ids
: 一個tensor
,資料型別必須是int32
,資料維度是一維的。裡面的值是有序排列的,但是可以重複。
name
:(可選)為這個操作取一個名字。
輸出引數:
* 一個Tensor
,資料型別和data
相同,資料的第一維度是k
,其餘維度和data
相同。
序列比較和索引函式
TensorFlow提供了一些操作,你可以使用這些函式去處理序列比較和索引提取,並且新增到你的圖中。你可以使用這些函式去確定一些序列之間的差異,以及確定tensor
中一些特定的值的索引。
tf.argmin(input, dimension, name=None)
解釋:這個函式的作用是返回指定維度中的最小值的索引。
使用例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
a = tf.constant([[11,22,3,4], [2,6,3,1]])
c = tf.argmin(a, 1)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼
輸入引數:
* input
: 一個Tensor
,資料型別必須是以下之一:float32
,float64
,int64
,int32
,uint8
,uint16
,int8
,complex64
,qint8
,qint32
。
* dimension
: 一個tensor
,資料型別是int32
,0 <= dimension < rank(input)
。這個引數選定了需要合併處理的哪個維度。如果輸入input
是一個向量,那麼我們取dimension = 0
。
* name
:(可選)為這個操作取一個名字。
輸出引數:
* 一個Tensor
,資料型別是int64
。
tf.argmax(input, dimension, name=None)
解釋:這個函式的作用是返回指定維度中的最大值的索引。
使用例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
a = tf.constant([[11,22,3,4], [2,6,3,1]])
c = tf.argmax(a, 1)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼
輸入引數:
* input
: 一個Tensor
,資料型別必須是以下之一:float32
,float64
,int64
,int32
,uint8
,uint16
,int8
,complex64
,qint8
,qint32
。
* dimension
: 一個tensor
,資料型別是int32
,0 <= dimension < rank(input)
。這個引數選定了需要合併處理的哪個維度。如果輸入input
是一個向量,那麼我們取dimension = 0
。
* name
:(可選)為這個操作取一個名字。
輸出引數:
* 一個Tensor
,資料型別是int64
。
tf.listdiff(x, y, name=None)
解釋:這個函式的作用是計算兩個列表中元素的不同值。
給定一個列表x
和列表y
,這個操作返回一個列表out
,列表中的元素是存在於x
中,但不存在於y
中。列表out
中的元素是按照原來x
中的順序是一樣的。這個操作也返回一個索引列表idx
,表示out
中的值在原來x
中的索引位置,即:
out[i] = x[idx[i]] for i in [0, 1, ..., len(out) - 1]複製程式碼
比如:
輸入資料為:
x = [1, 2, 3, 4, 5, 6]
y = [1, 3, 5]複製程式碼
輸出資料為:
out ==> [2, 4, 6]
idx ==> [1, 3, 5]複製程式碼
使用例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
a = tf.constant([2,6,3,1])
b = tf.constant([11,22,3,4, 8])
c = tf.listdiff(a, b)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼
輸入引數:
* x
: 一個一維的Tensor
,裡面的值是需要保留的。
* y
: 一個一維的tensor
,資料型別和x
相同,裡面的值是需要去除的。
* name
:(可選)為這個操作取一個名字。
輸出引數:
一個tensor
元祖,裡面的元素為(out, idx)
。
out
: 一個tensor
,資料型別和x
相同,資料維度是一維的,裡面的元素存在於x
中,但不存在與y
中。idx
: 一個tensor
,資料型別是int32
,資料維度是一維的,裡面的元素表示out
中的值在原來x
中的索引位置。
tf.where(input, name=None)
解釋:這個函式的作用是返回input
中元素是true
的位置。
這個操作是返回input
中值為true
的座標。座標是儲存在一個二維的tensor
中,其中第一維度表示true
元素的個數,第二維度表示true
元素的座標。記住,輸出tensor
的維度依賴於input
中true
的個數。並且裡面的座標排序按照input
中的排序。
比如:
# `input` tensor is [[True, False]
# [True, False]]
# `input` has two true values, so output has two coordinates.
# `input` has rank of 2, so coordinates have two indices.
where(input) ==> [[0, 0],
[1, 0]]
# `input` tensor is [[[True, False]
# [True, False]]
# [[False, True]
# [False, True]]
# [[False, False]
# [False, True]]]
# `input` has 5 true values, so output has 5 coordinates.
# `input` has rank of 3, so coordinates have three indices.
where(input) ==> [[0, 0, 0],
[0, 1, 0],
[1, 0, 1],
[1, 1, 1],
[2, 1, 1]]複製程式碼
使用例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
a = tf.constant([[True, False],[False, True]])
c = tf.where(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼
輸入引數:
* input
: 一個Tensor
,資料型別是布林型別bool
。
* name
:(可選)為這個操作取一個名字。
輸出引數:
- 一個
tensor
,資料型別是int64
。
tf.unique(x, name=None)
解釋:這個函式的作用是找到x
中的唯一元素。
這個操作是返回一個張量y
,裡面的元素都是x
中唯一的值,並且按照原來x
中的順序進行排序。這個操作還會返回一個位置張量idx
,這個張量的資料維度和x
相同,表示的含義是x
中的元素在y
中的索引位置,即:
y[idx[i]] = x[i] for i in [0, 1,...,rank(x) - 1]複製程式碼
比如:
# tensor `x` is [1, 1, 2, 4, 4, 4, 7, 8, 8]
y, idx = unique(x)
y ==> [1, 2, 4, 7, 8]
idx ==> [0, 0, 1, 2, 2, 2, 3, 4, 4]複製程式碼
使用例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
a = tf.constant([1, 1, 24, 4, 4, 4, 7, 8, 8])
c, d = tf.unique(a)
sess = tf.Session()
print sess.run(c)
print sess.run(d)
sess.close()複製程式碼
輸入引數:
* x
: 一個Tensor
,資料維度是一維的。
* name
:(可選)為這個操作取一個名字。
輸出引數:
一個tensor
元祖,裡面的元素為(y, idx)
。
y
: 一個tensor
,資料型別和x
相同,資料維度是一維的。idx
: 一個tensor
,資料型別是int32
,資料維度是一維的。
tf.edit_distance(hypothesis, truth, normalize=True, name=`edit_distance`)
解釋:這個函式的作用是計算兩個序列之間的編輯距離,即Levenshtein距離。
這個操作輸入的是兩個可變長度序列hypothesis
和truth
,每個序列都是SparseTensor
,之後計算編輯距離。如果你將normalize
設定為true
,那麼最後結果將根據truth
的長度進行歸一化。
比如:
輸入資料:
# `hypothesis` is a tensor of shape `[2, 1]` with variable-length values:
# (0,0) = ["a"]
# (1,0) = ["b"]
hypothesis = tf.SparseTensor(
[[0, 0, 0],
[1, 0, 0]],
["a", "b"]
(2, 1, 1))
# `truth` is a tensor of shape `[2, 2]` with variable-length values:
# (0,0) = []
# (0,1) = ["a"]
# (1,0) = ["b", "c"]
# (1,1) = ["a"]
truth = tf.SparseTensor(
[[0, 1, 0],
[1, 0, 0],
[1, 0, 1],
[1, 1, 0]]
["a", "b", "c", "a"],
(2, 2, 2))
normalize = True複製程式碼
輸出資料:
# `output` is a tensor of shape `[2, 2]` with edit distances normalized
# by `truth` lengths.
output ==> [[inf, 1.0], # (0,0): no truth, (0,1): no hypothesis
[0.5, 1.0]] # (1,0): addition, (1,1): no hypothesis複製程式碼
使用例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
hypothesis = tf.SparseTensor(
[[0, 0, 0],
[1, 0, 0]],
["a", "b"],
(2, 1, 1))
truth = tf.SparseTensor(
[[0, 1, 0],
[1, 0, 0],
[1, 0, 1],
[1, 1, 0]],
["a", "b", "c", "a"],
(2, 2, 2))
c = tf.edit_distance(hypothesis, truth)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼
輸入引數:
hypothesis
: 一個SparseTensor
,表示猜測的資料序列。truth
: 一個SparseTensor
,表示真實的資料序列。normalize
: 一個布林型別,如果設定為true
,那麼最後結果將根據truth
的長度進行歸一化。name
:(可選)為這個操作取一個名字。
輸出引數:
- 一個密集
tensor
,其秩為R-1
。其中,R
是輸入hypothesis
和truth
的秩。
異常:
型別異常
: 如果hypothesis
和truth
不是SparseTensor
型別的,那麼就會丟擲這個異常。
tf.invert_permutation(x, name=None)
解釋:這個函式的作用是計算張量x
的逆置換。
這個操作是計算張量x
的逆置換。輸入引數x
是一個一維的整型tensor
,它表示一個從0開始的陣列的索引,並且交換其索引位置的每個值,得到的結果就是輸出y
。 輸出結果y
的具體計算公式如下:
y[x[i]] = i for i in [0, 1, ..., len(x) - 1]複製程式碼
該引數x
必須包含0,並且不能有重複資料和負數。
比如:
# tensor `x` is [3, 4, 0, 2, 1]
invert_permutation(x) ==> [2, 4, 3, 0, 1]複製程式碼
使用例子:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import tensorflow as tf
import numpy as np
a = tf.constant([3, 4, 0, 2, 1])
c = tf.invert_permutation(a)
sess = tf.Session()
print sess.run(c)
sess.close()複製程式碼
輸入引數:
x
: 一個Tensor
,資料型別是int32
,資料維度是一維的。name
:(可選)為這個操作取一個名字。
輸出引數:
- 一個
tensor
,資料型別是int32
,資料維度是一維的。
CoderPai 是一個專注於演算法實戰的平臺,從基礎的演算法到人工智慧演算法都有設計。如果你對演算法實戰感興趣,請快快關注我們吧。加入AI實戰微信群,AI實戰QQ群,ACM演算法微信群,ACM演算法QQ群。詳情請關注 “CoderPai” 微訊號(coderpai) 。