摘要：使用例子輸入?yún)?shù)一個(gè)，數(shù)據(jù)類(lèi)型必須是以下之一，，，，，，。解釋這個(gè)函數(shù)的作用是沿著指定的維度，分割張量中的值，并且返回最大值。

作者：chen_h
微信號(hào) & QQ：862251340
微信公眾號(hào)：coderpai
簡(jiǎn)書(shū)地址：https://www.jianshu.com/p/4da...

計(jì)劃現(xiàn)將 tensorflow 中的 Python API 做一個(gè)學(xué)習(xí)，這樣方便以后的學(xué)習(xí)。
原文鏈接

第一部分

第二部分

減少元素操作

TensorFlow提供了一些操作，你可以用它來(lái)執(zhí)行常見(jiàn)的數(shù)學(xué)運(yùn)算，以此減少?gòu)埩康木S度。

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

解釋?zhuān)哼@個(gè)函數(shù)的作用是計(jì)算指定維度的元素總和。

沿著給定的reduction_indices維度，累加input_tensor中該維度的元素，最后返回累加的值。如果keep_dims = False，沿著reduction_indices維度進(jìn)行累加，最后返回一個(gè)秩為1的tensor。如果keep_dims = True，那么每一維度的累加值返回一個(gè)秩為1的tensor。

如果reduction_indices沒(méi)有給定，那么我們將input_tensor中的元素全部進(jìn)行累加，最后返回一個(gè)標(biāo)量。

比如：

# "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()

輸入?yún)?shù)：

input_tensor: 一個(gè)累加的Tensor，它應(yīng)該是數(shù)字類(lèi)型。

reduction_indices: 指定累加的維度。如果是None，那么累加所有的元素。

keep_dims: 如果是True，那么指定維度中的元素累加返回一個(gè)秩為1的Tensor。如果是False，那么返回一個(gè)累加的標(biāo)量。

name:（可選）為這個(gè)操作取一個(gè)名字。

輸出參數(shù)：

一個(gè)累加的Tensor。

tf.reduce_prod(input_tensor, reduction_indices=None, keep_dims=False, name=None)

解釋?zhuān)哼@個(gè)函數(shù)的作用是計(jì)算指定維度的元素相乘的總和。

沿著給定的reduction_indices維度，累乘input_tensor中該維度的元素，最后返回累乘的值。如果keep_dims = False，沿著reduction_indices維度進(jìn)行累乘，最后返回一個(gè)秩為1的tensor。如果keep_dims = True，那么每一維度的累乘值返回一個(gè)秩為1的tensor。

如果reduction_indices沒(méi)有給定，那么我們將input_tensor中的元素全部進(jìn)行累乘，最后返回一個(gè)標(biāo)量。

使用例子：

#!/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()

輸入?yún)?shù)：

input_tensor: 一個(gè)累乘的Tensor，它應(yīng)該是數(shù)字類(lèi)型。

reduction_indices: 指定累乘的維度。如果是None，那么累乘所有的元素。

keep_dims: 如果是True，那么指定維度中的元素累乘返回一個(gè)秩為1的Tensor。如果是False，那么返回一個(gè)累乘的標(biāo)量。

name:（可選）為這個(gè)操作取一個(gè)名字。

輸出參數(shù)：

一個(gè)累乘的Tensor。

tf.reduce_min(input_tensor, reduction_indices=None, keep_dims=False, name=None)

解釋?zhuān)哼@個(gè)函數(shù)的作用是計(jì)算指定維度的元素中的最小值。

沿著給定的reduction_indices維度，找到input_tensor中該維度的元素的最小值，最后返回這個(gè)最小值。如果keep_dims = False，沿著reduction_indices維度尋找最小值，最后返回一個(gè)秩為1的tensor。如果keep_dims = True，那么每一維度的最小值返回一個(gè)秩為1的tensor。

如果reduction_indices沒(méi)有給定，那么我們?nèi)?b>input_tensor中的最小元素，最后返回一個(gè)標(biāo)量。

使用例子：

#!/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()

輸入?yún)?shù)：

input_tensor: 一個(gè)需要處理的Tensor，它應(yīng)該是數(shù)字類(lèi)型。

reduction_indices: 指定需要查找最小值的維度。如果是None，那么從所有的元素中找最小值。

keep_dims: 如果是True，那么指定維度中的最小值返回一個(gè)秩為1的Tensor。如果是False，那么返回一個(gè)最小值的標(biāo)量。

name:（可選）為這個(gè)操作取一個(gè)名字。

輸出參數(shù)：

一個(gè)處理之后的Tensor。

tf.reduce_max(input_tensor, reduction_indices=None, keep_dims=False, name=None)

解釋?zhuān)哼@個(gè)函數(shù)的作用是計(jì)算指定維度的元素中的最大值。

沿著給定的reduction_indices維度，找到input_tensor中該維度的元素的最大值，最后返回這個(gè)最大值。如果keep_dims = False，沿著reduction_indices維度尋找最大值，最后返回一個(gè)秩為1的tensor。如果keep_dims = True，那么每一維度的最大值返回一個(gè)秩為1的tensor。

如果reduction_indices沒(méi)有給定，那么我們?nèi)?b>input_tensor中的最大元素，最后返回一個(gè)標(biāo)量。

使用例子：

#!/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()

輸入?yún)?shù)：

input_tensor: 一個(gè)需要處理的Tensor，它應(yīng)該是數(shù)字類(lèi)型。

reduction_indices: 指定需要查找最大值的維度。如果是None，那么從所有的元素中找最大值。

keep_dims: 如果是True，那么指定維度中的最大值返回一個(gè)秩為1的Tensor。如果是False，那么返回一個(gè)最大值的標(biāo)量。

name:（可選）為這個(gè)操作取一個(gè)名字。

輸出參數(shù)：

一個(gè)處理之后的Tensor。

tf.reduce_mean(input_tensor, reduction_indices=None, keep_dims=False, name=None)

解釋?zhuān)哼@個(gè)函數(shù)的作用是計(jì)算指定維度中的元素的平均值。

沿著給定的reduction_indices維度，找到input_tensor中該維度的元素的平均值，最后返回這個(gè)平均值。如果keep_dims = False，沿著reduction_indices維度尋找平均值，最后返回一個(gè)秩為1的tensor。如果keep_dims = True，那么每一維度的平均值返回一個(gè)秩為1的tensor。

如果reduction_indices沒(méi)有給定，那么我們?nèi)?b>input_tensor中的平均值，最后返回一個(gè)標(biāo)量。

比如：

# "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()

輸入?yún)?shù)：

input_tensor: 一個(gè)需要處理的Tensor，它應(yīng)該是數(shù)字類(lèi)型。

reduction_indices: 指定需要查找平均值的維度。如果是None，那么從所有的元素中找平均值。

keep_dims: 如果是True，那么指定維度中的平均值返回一個(gè)秩為1的Tensor。如果是False，那么返回一個(gè)平均值的標(biāo)量。

name:（可選）為這個(gè)操作取一個(gè)名字。

輸出參數(shù)：

一個(gè)處理之后的Tensor。

tf.reduce_all(input_tensor, reduction_indices=None, keep_dims=False, name=None)

解釋?zhuān)哼@個(gè)函數(shù)的作用是計(jì)算指定維度中的元素的邏輯與。

沿著給定的reduction_indices維度，找到input_tensor中該維度的元素的邏輯與，最后返回這個(gè)邏輯與值。如果keep_dims = False，沿著reduction_indices維度尋找邏輯與值，最后返回一個(gè)秩為1的tensor。如果keep_dims = True，那么每一維度的邏輯與值返回一個(gè)秩為1的tensor。

如果reduction_indices沒(méi)有給定，那么我們?nèi)?b>input_tensor中的邏輯與值，最后返回一個(gè)標(biāo)量。

比如：

# "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()

輸入?yún)?shù)：

input_tensor: 一個(gè)需要處理的Tensor，它應(yīng)該是數(shù)字類(lèi)型。

reduction_indices: 指定需要查找邏輯與值的維度。如果是None，那么從所有的元素中找邏輯與值。

keep_dims: 如果是True，那么指定維度中的邏輯與值返回一個(gè)秩為1的Tensor。如果是False，那么返回一個(gè)邏輯與值的標(biāo)量。

name:（可選）為這個(gè)操作取一個(gè)名字。

輸出參數(shù)：

一個(gè)處理之后的Tensor。

tf.reduce_any(input_tensor, reduction_indices=None, keep_dims=False, name=None)

解釋?zhuān)哼@個(gè)函數(shù)的作用是計(jì)算指定維度中的元素的邏輯或。

沿著給定的reduction_indices維度，找到input_tensor中該維度的元素的邏輯或，最后返回這個(gè)邏輯或值。如果keep_dims = False，沿著reduction_indices維度尋找邏輯或值，最后返回一個(gè)秩為1的tensor。如果keep_dims = True，那么每一維度的邏輯或值返回一個(gè)秩為1的tensor。

如果reduction_indices沒(méi)有給定，那么我們?nèi)?b>input_tensor中的邏輯或值，最后返回一個(gè)標(biāo)量。

比如：

# "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()

輸入?yún)?shù)：

input_tensor: 一個(gè)需要處理的Tensor，它應(yīng)該是數(shù)字類(lèi)型。

reduction_indices: 指定需要查找邏輯或值的維度。如果是None，那么從所有的元素中找邏輯或值。

keep_dims: 如果是True，那么指定維度中的邏輯或值返回一個(gè)秩為1的Tensor。如果是False，那么返回一個(gè)邏輯或值的標(biāo)量。

name:（可選）為這個(gè)操作取一個(gè)名字。

輸出參數(shù)：

一個(gè)處理之后的Tensor。

tf.accumulate_n(inputs, shape=None, tensor_dtype=None, name=None)

解釋?zhuān)哼@個(gè)函數(shù)的作用是計(jì)算張量列表中每個(gè)對(duì)應(yīng)的元素的累加和。

其中，shape和tensor_dtype是可選項(xiàng)，主要是為了驗(yàn)證最后返回的累加值的數(shù)據(jù)維度和數(shù)據(jù)類(lèi)型是否和猜測(cè)的一樣，如果不一樣，將會(huì)報(bào)錯(cuò)。

比如：

# 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()

輸入?yún)?shù)：

inputs: 一個(gè)需要處理的Tensor列表，其中每一個(gè)tensor都必須擁有相同的數(shù)據(jù)維度和數(shù)據(jù)類(lèi)型。

shape: inputs的數(shù)據(jù)維度。

tensor_dtype: inputs的數(shù)據(jù)類(lèi)型。

name:（可選）為這個(gè)操作取一個(gè)名字。

輸出參數(shù)：

一個(gè)Tensor，數(shù)據(jù)維度和數(shù)據(jù)類(lèi)型都和inputs相同。

異常：

如果inputs中每一個(gè)tensor的數(shù)據(jù)維度不一樣，或者推測(cè)的數(shù)據(jù)維度或數(shù)據(jù)類(lèi)型不正確，那么都會(huì)拋出異常。

分割操作

TensorFlow提供了一些操作，你可以使用基本的算術(shù)運(yùn)算來(lái)分割輸入的tensor。這里的分割操作是沿著第一個(gè)維度的一個(gè)分區(qū)，等價(jià)于這里定義了一個(gè)從第一個(gè)維度到第segment_ids維度的一個(gè)映射。segment_ids張量的長(zhǎng)度必須和需要分割的tensor的第一維度的尺寸d0一樣，其中segment_ids中的編號(hào)從0到k，并且k < d0。舉個(gè)例子，如果我們需要分割的tensor是一個(gè)矩陣，那么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)

解釋?zhuān)哼@個(gè)函數(shù)的作用是沿著segment_ids指定的維度，分割張量data中的值，并且返回累加值。

計(jì)算公式為:

其中，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()

輸入?yún)?shù)：

data: 一個(gè)Tensor，數(shù)據(jù)類(lèi)型必須是以下之一：float32，float64，int32，int64，uint8，int16，int8。

segment_ids: 一個(gè)tensor，數(shù)據(jù)類(lèi)型必須是int32或者int64，數(shù)據(jù)維度是一維的，并且長(zhǎng)度和data第一維度的長(zhǎng)度相同。里面的值是從0到k的有序排列，但是可以重復(fù)。

name:（可選）為這個(gè)操作取一個(gè)名字。

輸出參數(shù)：

一個(gè)Tensor，數(shù)據(jù)類(lèi)型和data相同，數(shù)據(jù)的第一維度是k，其余維度和data相同。

tf.segment_prod(data, segment_ids, name=None)

解釋?zhuān)哼@個(gè)函數(shù)的作用是沿著segment_ids指定的維度，分割張量data中的值，并且返回累乘值。

計(jì)算公式為:

其中，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()

輸入?yún)?shù)：

data: 一個(gè)Tensor，數(shù)據(jù)類(lèi)型必須是以下之一：float32，float64，int32，int64，uint8，int16，int8。

segment_ids: 一個(gè)tensor，數(shù)據(jù)類(lèi)型必須是int32或者int64，數(shù)據(jù)維度是一維的，并且長(zhǎng)度和data第一維度的長(zhǎng)度相同。里面的值是從0到k的有序排列，但是可以重復(fù)。

name:（可選）為這個(gè)操作取一個(gè)名字。

輸出參數(shù)：

一個(gè)Tensor，數(shù)據(jù)類(lèi)型和data相同，數(shù)據(jù)的第一維度是k，其余維度和data相同。

tf.segment_min(data, segment_ids, name=None)

解釋?zhuān)哼@個(gè)函數(shù)的作用是沿著segment_ids指定的維度，分割張量data中的值，并且返回最小值。

計(jì)算公式為:

其中，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()

輸入?yún)?shù)：

data: 一個(gè)Tensor，數(shù)據(jù)類(lèi)型必須是以下之一：float32，float64，int32，int64，uint8，int16，int8。

segment_ids: 一個(gè)tensor，數(shù)據(jù)類(lèi)型必須是int32或者int64，數(shù)據(jù)維度是一維的，并且長(zhǎng)度和data第一維度的長(zhǎng)度相同。里面的值是從0到k的有序排列，但是可以重復(fù)。

name:（可選）為這個(gè)操作取一個(gè)名字。

輸出參數(shù)：

一個(gè)Tensor，數(shù)據(jù)類(lèi)型和data相同，數(shù)據(jù)的第一維度是k，其余維度和data相同。

tf.segment_max(data, segment_ids, name=None)

解釋?zhuān)哼@個(gè)函數(shù)的作用是沿著segment_ids指定的維度，分割張量data中的值，并且返回最大值。

計(jì)算公式為:

其中，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()

輸入?yún)?shù)：

data: 一個(gè)Tensor，數(shù)據(jù)類(lèi)型必須是以下之一：float32，float64，int32，int64，uint8，int16，int8。

segment_ids: 一個(gè)tensor，數(shù)據(jù)類(lèi)型必須是int32或者int64，數(shù)據(jù)維度是一維的，并且長(zhǎng)度和data第一維度的長(zhǎng)度相同。里面的值是從0到k的有序排列，但是可以重復(fù)。

name:（可選）為這個(gè)操作取一個(gè)名字。

輸出參數(shù)：

一個(gè)Tensor，數(shù)據(jù)類(lèi)型和data相同，數(shù)據(jù)的第一維度是k，其余維度和data相同。

tf.segment_mean(data, segment_ids, name=None)

解釋?zhuān)哼@個(gè)函數(shù)的作用是沿著segment_ids指定的維度，分割張量data中的值，并且返回平均值。

計(jì)算公式為:

其中，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()

輸入?yún)?shù)：

data: 一個(gè)Tensor，數(shù)據(jù)類(lèi)型必須是以下之一：float32，float64，int32，int64，uint8，int16，int8。

segment_ids: 一個(gè)tensor，數(shù)據(jù)類(lèi)型必須是int32或者int64，數(shù)據(jù)維度是一維的，并且長(zhǎng)度和data第一維度的長(zhǎng)度相同。里面的值是從0到k的有序排列，但是可以重復(fù)。

name:（可選）為這個(gè)操作取一個(gè)名字。

輸出參數(shù)：

一個(gè)Tensor，數(shù)據(jù)類(lèi)型和data相同，數(shù)據(jù)的第一維度是k，其余維度和data相同。

tf.unsorted_segment_sum(data, segment_ids, num_segments, name=None)

解釋?zhuān)哼@個(gè)函數(shù)的作用是沿著segment_ids指定的維度，分割張量data中的值，并且返回累加值。

計(jì)算公式為:

其中，segment_ids[j] == i。這個(gè)API和SegmentSum最大的區(qū)別是，這個(gè)API不需要從0到k有序排列，可以亂序排列，并且該API不需要包含從0到k。

如果對(duì)于給定的分割區(qū)間ID i，output[i] = 0。那么，num_segmetns應(yīng)該等于不同的段ID的數(shù)量。

使用例子：

#!/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()

輸入?yún)?shù)：

data: 一個(gè)Tensor，數(shù)據(jù)類(lèi)型必須是以下之一：float32，float64，int32，int64，uint8，int16，int8。

segment_ids: 一個(gè)tensor，數(shù)據(jù)類(lèi)型必須是int32或者int64，數(shù)據(jù)維度是一維的，并且長(zhǎng)度和data第一維度的長(zhǎng)度相同。

num_segments: 一個(gè)tensor，數(shù)據(jù)類(lèi)型是int32。

name:（可選）為這個(gè)操作取一個(gè)名字。

輸出參數(shù)：

一個(gè)Tensor，數(shù)據(jù)類(lèi)型和data相同，數(shù)據(jù)的第一維度是num_segments，其余維度和data相同。

tf.sparse_segment_sum(data, indices, segment_ids, name=None)

解釋?zhuān)哼@個(gè)函數(shù)的作用是沿著segment_ids指定的維度，分割張量data中的值，并且返回累加值。

該API和SegmentSum差不多，但是該API的segment_ids的長(zhǎng)度可以小于data的第一維度的長(zhǎng)度，而是從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()

輸入?yún)?shù)：

data: 一個(gè)Tensor，數(shù)據(jù)類(lèi)型必須是以下之一：float32，float64，int32，int64，uint8，int16，int8。

indices: 一個(gè)tensor，數(shù)據(jù)類(lèi)型是int32，數(shù)據(jù)維度是一維的，長(zhǎng)度和segment_ids相同。

segment_ids: 一個(gè)tensor，數(shù)據(jù)類(lèi)型必須是int32，數(shù)據(jù)維度是一維的。里面的值是有序排列的，但是可以重復(fù)。

name:（可選）為這個(gè)操作取一個(gè)名字。

輸出參數(shù)：

一個(gè)Tensor，數(shù)據(jù)類(lèi)型和data相同，數(shù)據(jù)的第一維度是k，其余維度和data相同。

tf.sparse_segment_mean(data, indices, segment_ids, name=None)

解釋?zhuān)哼@個(gè)函數(shù)的作用是沿著segment_ids指定的維度，分割張量data中的值，并且返回累加值。

該API和SegmentSum差不多，但是該API的segment_ids的長(zhǎng)度可以小于data的第一維度的長(zhǎng)度，而是從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()

輸入?yún)?shù)：

data: 一個(gè)Tensor，數(shù)據(jù)類(lèi)型必須是以下之一：float32，float64。

indices: 一個(gè)tensor，數(shù)據(jù)類(lèi)型是int32，數(shù)據(jù)維度是一維的，長(zhǎng)度和segment_ids相同。

segment_ids: 一個(gè)tensor，數(shù)據(jù)類(lèi)型必須是int32，數(shù)據(jù)維度是一維的。里面的值是有序排列的，但是可以重復(fù)。

name:（可選）為這個(gè)操作取一個(gè)名字。

輸出參數(shù)：

一個(gè)Tensor，數(shù)據(jù)類(lèi)型和data相同，數(shù)據(jù)的第一維度是k，其余維度和data相同。

序列比較和索引函數(shù)

TensorFlow提供了一些操作，你可以使用這些函數(shù)去處理序列比較和索引提取，并且添加到你的圖中。你可以使用這些函數(shù)去確定一些序列之間的差異，以及確定tensor中一些特定的值的索引。

tf.argmin(input, dimension, name=None)

解釋?zhuān)哼@個(gè)函數(shù)的作用是返回指定維度中的最小值的索引。

使用例子：

#!/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()

輸入?yún)?shù)：

input: 一個(gè)Tensor，數(shù)據(jù)類(lèi)型必須是以下之一：float32，float64，int64，int32，uint8，uint16，int8，complex64，qint8，qint32。

dimension: 一個(gè)tensor，數(shù)據(jù)類(lèi)型是int32，0 <= dimension < rank(input)。這個(gè)參數(shù)選定了需要合并處理的哪個(gè)維度。如果輸入input是一個(gè)向量，那么我們?nèi)?b>dimension = 0。

name:（可選）為這個(gè)操作取一個(gè)名字。

輸出參數(shù)：

一個(gè)Tensor，數(shù)據(jù)類(lèi)型是int64。

tf.argmax(input, dimension, name=None)

解釋?zhuān)哼@個(gè)函數(shù)的作用是返回指定維度中的最大值的索引。

使用例子：

#!/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()

輸入?yún)?shù)：

input: 一個(gè)Tensor，數(shù)據(jù)類(lèi)型必須是以下之一：float32，float64，int64，int32，uint8，uint16，int8，complex64，qint8，qint32。

dimension: 一個(gè)tensor，數(shù)據(jù)類(lèi)型是int32，0 <= dimension < rank(input)。這個(gè)參數(shù)選定了需要合并處理的哪個(gè)維度。如果輸入input是一個(gè)向量，那么我們?nèi)?b>dimension = 0。

name:（可選）為這個(gè)操作取一個(gè)名字。

輸出參數(shù)：

一個(gè)Tensor，數(shù)據(jù)類(lèi)型是int64。

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

解釋?zhuān)哼@個(gè)函數(shù)的作用是計(jì)算兩個(gè)列表中元素的不同值。

給定一個(gè)列表x和列表y，這個(gè)操作返回一個(gè)列表out，列表中的元素是存在于x中，但不存在于y 中。列表out中的元素是按照原來(lái)x中的順序是一樣的。這個(gè)操作也返回一個(gè)索引列表idx，表示out中的值在原來(lái)x中的索引位置，即：

out[i] = x[idx[i]] for i in [0, 1, ..., len(out) - 1]

比如：

輸入數(shù)據(jù)為：

x = [1, 2, 3, 4, 5, 6]
y = [1, 3, 5]

輸出數(shù)據(jù)為：

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()

輸入?yún)?shù)：

x: 一個(gè)一維的Tensor，里面的值是需要保留的。

y: 一個(gè)一維的tensor，數(shù)據(jù)類(lèi)型和x相同，里面的值是需要去除的。

name:（可選）為這個(gè)操作取一個(gè)名字。

輸出參數(shù)：

一個(gè)tensor元祖，里面的元素為(out, idx)。

out: 一個(gè)tensor，數(shù)據(jù)類(lèi)型和x相同，數(shù)據(jù)維度是一維的，里面的元素存在于x中，但不存在與y中。

idx: 一個(gè)tensor，數(shù)據(jù)類(lèi)型是int32，數(shù)據(jù)維度是一維的，里面的元素表示out中的值在原來(lái)x中的索引位置。

tf.where(input, name=None)

解釋?zhuān)哼@個(gè)函數(shù)的作用是返回input中元素是true的位置。

這個(gè)操作是返回input中值為true的坐標(biāo)。坐標(biāo)是保存在一個(gè)二維的tensor中，其中第一維度表示true元素的個(gè)數(shù)，第二維度表示true元素的坐標(biāo)。記住，輸出tensor的維度依賴(lài)于input中true的個(gè)數(shù)。并且里面的坐標(biāo)排序按照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()

輸入?yún)?shù)：

input: 一個(gè)Tensor，數(shù)據(jù)類(lèi)型是布爾類(lèi)型bool。

name:（可選）為這個(gè)操作取一個(gè)名字。

輸出參數(shù)：

一個(gè)tensor，數(shù)據(jù)類(lèi)型是int64。

tf.unique(x, name=None)

解釋?zhuān)哼@個(gè)函數(shù)的作用是找到x中的唯一元素。

這個(gè)操作是返回一個(gè)張量y，里面的元素都是x中唯一的值，并且按照原來(lái)x中的順序進(jìn)行排序。這個(gè)操作還會(huì)返回一個(gè)位置張量idx，這個(gè)張量的數(shù)據(jù)維度和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()

輸入?yún)?shù)：

x: 一個(gè)Tensor，數(shù)據(jù)維度是一維的。

name:（可選）為這個(gè)操作取一個(gè)名字。

輸出參數(shù)：

一個(gè)tensor元祖，里面的元素為(y, idx)。

y: 一個(gè)tensor，數(shù)據(jù)類(lèi)型和x相同，數(shù)據(jù)維度是一維的。

idx: 一個(gè)tensor，數(shù)據(jù)類(lèi)型是int32，數(shù)據(jù)維度是一維的。

tf.edit_distance(hypothesis, truth, normalize=True, name="edit_distance")

解釋?zhuān)哼@個(gè)函數(shù)的作用是計(jì)算兩個(gè)序列之間的編輯距離，即Levenshtein距離。

這個(gè)操作輸入的是兩個(gè)可變長(zhǎng)度序列hypothesis和truth，每個(gè)序列都是SparseTensor，之后計(jì)算編輯距離。如果你將normalize設(shè)置為true，那么最后結(jié)果將根據(jù)truth的長(zhǎng)度進(jìn)行歸一化。

比如：

輸入數(shù)據(jù)：

# "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

輸出數(shù)據(jù)：

# "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()

輸入?yún)?shù)：

hypothesis: 一個(gè)SparseTensor，表示猜測(cè)的數(shù)據(jù)序列。

truth: 一個(gè)SparseTensor，表示真實(shí)的數(shù)據(jù)序列。

normalize: 一個(gè)布爾類(lèi)型，如果設(shè)置為true，那么最后結(jié)果將根據(jù)truth的長(zhǎng)度進(jìn)行歸一化。

name:（可選）為這個(gè)操作取一個(gè)名字。

輸出參數(shù)：

一個(gè)密集tensor，其秩為R-1。其中，R是輸入hypothesis和truth的秩。

異常:

類(lèi)型異常: 如果hypothesis和truth不是SparseTensor類(lèi)型的，那么就會(huì)拋出這個(gè)異常。

tf.invert_permutation(x, name=None)

解釋?zhuān)哼@個(gè)函數(shù)的作用是計(jì)算張量x的逆置換。

這個(gè)操作是計(jì)算張量x的逆置換。輸入?yún)?shù)x是一個(gè)一維的整型tensor，它表示一個(gè)從0開(kāi)始的數(shù)組的索引，并且交換其索引位置的每個(gè)值，得到的結(jié)果就是輸出y。 輸出結(jié)果y的具體計(jì)算公式如下：

y[x[i]] = i for i in [0, 1, ..., len(x) - 1]

該參數(shù)x必須包含0，并且不能有重復(fù)數(shù)據(jù)和負(fù)數(shù)。

比如：

# 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()

輸入?yún)?shù)：

x: 一個(gè)Tensor，數(shù)據(jù)類(lèi)型是int32，數(shù)據(jù)維度是一維的。

name:（可選）為這個(gè)操作取一個(gè)名字。

輸出參數(shù)：

一個(gè)tensor，數(shù)據(jù)類(lèi)型是int32，數(shù)據(jù)維度是一維的。

作者：chen_h
微信號(hào) & QQ：862251340
簡(jiǎn)書(shū)地址：https://www.jianshu.com/p/4da...

CoderPai 是一個(gè)專(zhuān)注于算法實(shí)戰(zhàn)的平臺(tái)，從基礎(chǔ)的算法到人工智能算法都有設(shè)計(jì)。如果你對(duì)算法實(shí)戰(zhàn)感興趣，請(qǐng)快快關(guān)注我們吧。加入AI實(shí)戰(zhàn)微信群，AI實(shí)戰(zhàn)QQ群，ACM算法微信群，ACM算法QQ群。長(zhǎng)按或者掃描如下二維碼，關(guān)注 “CoderPai” 微信號(hào)（coderpai）