Tensorflow Python API 翻譯（math_ops）（第二部分）

時間  2019-11-16
標籤 tensorflow python api 翻譯 math ops 第二 部分 欄目 Python 简体版
原文   原文鏈接

做者：chen_h
微信號 & QQ：862251340
微信公衆號：coderpai
個人博客：請點擊這裏python

計劃現將 tensorflow 中的 Python API 作一個學習，這樣方便之後的學習。
原文連接git

該章介紹有關數學符號操做的API

減小元素操做

TensorFlow提供了一些操做，你能夠用它來執行常見的數學運算，以此減小張量的維度。github

tf.reduce_sum(input_tensor, reduction_indices=None, keep_dims=False, name=None)算法

解釋：這個函數的做用是計算指定維度的元素總和。api

沿着給定的reduction_indices維度，累加input_tensor中該維度的元素，最後返回累加的值。若是keep_dims = False，沿着reduction_indices維度進行累加，最後返回一個秩爲1的tensor。若是keep_dims = True，那麼每一維度的累加值返回一個秩爲1的tensor。數組

若是reduction_indices沒有給定，那麼咱們將input_tensor中的元素所有進行累加，最後返回一個標量。bash

好比：微信

# '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複製代碼

使用例子：dom

#!/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。

Segment_Sum

使用例子：

#!/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。

Segment_Prod

使用例子：

#!/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。

Segment_Min

使用例子：

#!/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。

Segment_Max

使用例子：

#!/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。

Segment_Mean

使用例子：

#!/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的數量。

Unsorted_Segment_Sum

使用例子：

#!/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） 。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程