みらいテックラボ

音声・画像認識や機械学習など, 管理人が興味のある技術の紹介や実際にトライしてみた様子などメモしていく.

TensorFlow はじめの一歩(3)

今回は, 数学関数[1]に関するPython APIをベースに, どのような演算できるか確認してみる.
注) TensorFlow : Python API 0.6.0ベース

1. 四則演算

API機能
tf.add(x, y, name=None)加算 : x + y
tf.sub(x, y, name=None)減算 : x - y
tf.mul(x, y, name=None)乗算 : x * y
tf.div(x, y, name=None)除算 : x / y
tf.truediv(x, y, name=None)除算(浮動小数点数) : x / y
tf.floordiv(x, y, name=None)除算(切り下げ) : x / y
tf.mod(x, y, name=None)剰余 : x % y

サンプルコード:

import tensorflow as tf

sess = tf.InteractiveSession()

################
# tf.add
################
x = tf.constant([1., 2.])
y = tf.constant([0.5, 0.5])
tf_add = tf.add(x, y)
print "tf.add"
print sess.run(tf_add)

# output:

# tf.add
# [ 1.5  2.5]

################
# tf.sub
################
x = tf.constant([[1., 2.], [3., 4.]])
y = tf.constant([[0.5, 0.5], [1., 1.]])
tf_sub = tf.sub(x, y)
print "tf.sub"
print sess.run(tf_sub)

# output:

# tf.sub
# [[ 0.5  1.5]
#  [ 2.   3. ]]

################
# tf.mul
################
x = tf.constant([1., 2.])
y = tf.constant([[2.], [3.]])
tf_mul = tf.mul(x, y)
print "tf.mul"
print sess.run(tf_mul)

# output:

# tf.mul
# [[ 2.  4.]
#  [ 3.  6.]]

################
# tf.div
################
x = tf.constant([10, 15])
y = tf.constant([3])
tf_div = tf.div(x, y)
print "tf.div"
print sess.run(tf_div)

# output:

# tf.div
# [3 5]

################
# tf.truediv
################
x = tf.constant([10, 15])
y = tf.constant([3])
tf_truediv = tf.truediv(x, y)
print "tf.truediv"
print sess.run(tf_truediv)

# output:

# tf.truediv
# [ 3.33333333  5.        ]

################
# tf.floordiv
################
x = tf.constant([10., 15.])
y = tf.constant([3.])
tf_floordiv = tf.floordiv(x, y)
print "tf.floordiv"
print sess.run(tf_floordiv)

# output:

# tf.floordiv
# [ 3.  5.]

################
# tf.mod
################
x = tf.constant([10., 15.])
y = tf.constant([3.])
tf_mod = tf.mod(x, y)
print "tf.mod"
print sess.run(tf_mod)

# output:

# tf.mod
# [ 1.  0.]

sess.close()

2. 基本的な数学関数

API機能
tf.add_n(inputs, name=None)すべての入力Tensorを要素ごとに加算
tf.abs(x, name=None)Tensorの絶対値(|x|)を計算
tf.neg(x, name=None)要素ごとに半数(-x)を計算
tf.sign(x, name=None)要素ごとに数字の符号を返す
tf.inv(x, name=None)要素ごとに逆数(1/x)を計算
tf.square(x, name=None)要素ごとに2乗(x^2)を計算
tf.round(x, name=None)要素ごとに四捨五入した値を返す
tf.sqrt(x, name=None)要素ごとに平方根(√x)を計算
tf.rsqrt(x, name=None)要素ごとに平方根の逆数(1/√x)を計算
tf.pow(x, y, name=None)要素ごとに累乗(x^y)を計算
tf.exp(x, name=None)要素ごとに指数関数(e^x)を計算
tf.log(x, name=None)要素ごとに自然対数(log x)を計算
tf.ceil(x, name=None)要素ごとにxを下回らない最も小さい整数を返す
tf.floor(x, name=None)要素ごとにxを超えない最も大きい整数を返す
tf.maximum(x, y, name=None)要素ごとに最大値を返す
tf.minimum(x, y, name=None)要素ごとに最小値を返す
tf.cos(x, name=None)要素ごとに余弦(cos)を計算
tf.sin(x, name=None)要素ごとに正弦(sin)を計算

サンプルコード:

import tensorflow as tf

sess = tf.InteractiveSession()

################
# tf.add_n
################
a = tf.constant([1., 2.])
b = tf.constant([3., 4.])
c = tf.constant([5., 6.])
tf_addn = tf.add_n([a, b, c])
print "tf.add_n"
print sess.run(tf_addn)

# output:

# tf.add_n
# [  9.  12.]

################
# tf.abs
################
x = tf.constant([[-1., 2.], [3., -4.]])
tf_abs = tf.abs(x)
print "tf.abs"
print sess.run(tf_abs)

# output:

# tf.abs
# [[ 1.  2.]
#  [ 3.  4.]]

################
# tf.neg
################
x = tf.constant([[-1., 2.], [3., -4.]])
tf_neg = tf.neg(x)
print "tf.neg"
print sess.run(tf_neg)

# output:

# tf.neg
# [[ 1. -2.]
#  [-3.  4.]]

################
# tf.sign
################
x = tf.constant([[-1., 2.], [3., -4.]])
tf_sign = tf.sign(x)
print "tf.sign"
print sess.run(tf_sign)

# output:

# tf.sign
# [[-1.  1.]
#  [ 1. -1.]]

################
# tf.inv
################
x = tf.constant([[-1., 2.], [3., -4.]])
tf_inv = tf.inv(x)
print "tf.inv"
print sess.run(tf_inv)

# output:

# tf.inv
# [[-1.          0.5       ]
#  [ 0.33333334 -0.25      ]]

################
# tf.square
################
x = tf.constant([[-1., 2.], [3., -4.]])
tf_square = tf.square(x)
print "tf.square"
print sess.run(tf_square)

# output:

# tf.square
# [[  1.   4.]
#  [  9.  16.]]

################
# tf.round
################
x = tf.constant([0.9, 2.5, 2.3, -4.4])
tf_round = tf.round(x)
print "tf.round"
print sess.run(tf_round)

# output:

# tf.round
# [ 1.  3.  2. -4.]

################
# tf.sqrt
################
x = tf.constant([[1., 2.], [3., 4.]])
tf_sqrt = tf.sqrt(x)
print "tf.sqrt"
print sess.run(tf_sqrt)

# output:

# tf.sqrt
# [[ 0.99999994  1.41421342]
#  [ 1.73205078  1.99999988]]

################
# tf.rsqrt
################
x = tf.constant([[1., 2.], [3., 4.]])
tf_rsqrt = tf.rsqrt(x)
print "tf.rsqrt"
print sess.run(tf_rsqrt)

# output:

# tf.rsqrt
# [[ 0.99999994  0.70710671]
# [ 0.57735026  0.49999997]]

################
# tf.pow
################
x = tf.constant([[2, 2], [3, 3]])
y = tf.constant([[8, 16], [2, 3]])
tf_pow = tf.pow(x, y)
print "tf.pow"
print sess.run(tf_pow)

# output:

# tf.pow
# [[  256 65536]
#  [    9    27]]

################
# tf.exp
################
x = tf.constant([[1., 2.], [3., 4.]])
tf_exp = tf.exp(x)
print "tf.exp"
print sess.run(tf_exp)

# output:

# tf.exp
# [[  2.71828175   7.38905621]
#  [ 20.08553696  54.59815216]]

################
# tf.log
################
x = tf.constant([[1., 2.], [3., 4.]])
tf_log = tf.log(x)
print "tf.log"
print sess.run(tf_log)

# output:

# tf.log
# [[ 0.          0.69314718]
#  [ 1.09861231  1.38629436]]

################
# tf.ceil
################
x = tf.constant([[1.1, 2.2], [3.3, 4.4]])
tf_ceil = tf.ceil(x)
print "tf.ceil"
print sess.run(tf_ceil)

# output:

# tf.ceil
# [[ 2.  3.]
#  [ 4.  5.]]

################
# tf.floor
################
x = tf.constant([[1.1, 2.2], [3.3, 4.4]])
tf_floor = tf.floor(x)
print "tf.floor"
print sess.run(tf_floor)

# output:

# tf.floor
# [[ 1.  2.]
#  [ 3.  4.]]

################
# tf.maximum
################
x = tf.constant([[2, 8], [3, 12]])
y = tf.constant([[4, 10], [1, 9]])
tf_maximum = tf.maximum(x, y)
print "tf.maximum"
print sess.run(tf_maximum)

# output:

# tf.maximum
# [[ 4 10]
#  [ 3 12]]

################
# tf.minimum
################
x = tf.constant([[2, 8], [3, 12]])
y = tf.constant([[4, 10], [1, 9]])
tf_minimum = tf.minimum(x, y)
print "tf.minimum"
print sess.run(tf_minimum)

# output:

# tf.minimum
# [[2 8]
#  [1 9]]

################
# tf.cos
################
x = tf.constant([[2., 8.], [3., 12.]])
tf_cos = tf.cos(x)
print "tf.cos"
print sess.run(tf_cos)

# output:

# tf.cos
# [[-0.41614681 -0.14550003]
#  [-0.9899925   0.84385395]]

################
# tf.sin
################
x = tf.constant([[2., 8.], [3., 12.]])
tf_sin = tf.sin(x)
print "tf.sin"
print sess.run(tf_sin)

# output:

# tf.sin
# [[ 0.90929741  0.98935825]
#  [ 0.14112    -0.53657293]]

sess.close()

3. 行列演算関数

API機能
tf.diag(diagonal, name=None)対角成分を持つTensorを返す
tf.transpose(a, perm=None, name=transpose)行と列を入れ替える
tf.matmul(a, b, transpose_a=False, transpose_b=False, a_is_sparse=False, b_is_sparse=False, name=None)行列の積を計算
tf.batch_matmul(x, y, adj_x=None, adj_y=None, name=None)Tensorの行列スライスの積を計算
tf.matrix_determinant(input, name=None)正方行列の行列式を計算
tf.batch_matrix_determinant(input, name=None)Tensorの正方行列スライスの行列式を計算
tf.matrix_inverse(input, name=None)正方行列の逆行列を計算
tf.batch_matrix_inverse(input, name=None)Tensorの正方行列スライスの逆行列を計算
tf.cholesky(input, name=None)正方行列のコレスキー分解を計算
tf.batch_cholesky(input, name=None)Tensorの正方行列スライスのコレスキー分解を計算
tf.self_adjoint_eig(input, name=None)エルミート行列の固有値分解を計算
tf.batch_self_adjoint_eig(input, name=None)Tensorのエルミート行列スライスの固有値分解を計算

サンプルコード:

# -*- coding: utf-8 -*-

import tensorflow as tf

sess = tf.InteractiveSession()

################################
# tf.diag
################################
# 'diagonal' is [1, 2, 3, 4]
tf_diag = tf.diag([1, 2, 3, 4])
print "tf.diag"
print sess.run(tf_diag)

# output:

# tf.diag
# [[1 0 0 0]
#  [0 2 0 0]
#  [0 0 3 0]
#  [0 0 0 4]]

################################
# tf.transpose
################################
# 'x' is [[1 2 3]
#         [4 5 6]]
x = tf.constant([[1, 2, 3], [4, 5, 6]])
tf_trans = tf.transpose(x)
print "tf.transpose"
print sess.run(tf_trans)

# output:

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

# Equivalently
tf_trans = tf.transpose(x, perm=[1, 0])
print sess.run(tf_trans)

# output:

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

# 'perm' is more useful for n-dimensional tensors, for n > 2
# 'x' is   [[[1  2  3]
#            [4  5  6]]
#           [[7  8  9]
#            [10 11 12]]]
# Take the transpose of the matrices in dimension-0
x = tf.constant([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
tf_trans = tf.transpose(x, perm=[0, 2, 1])
print sess.run(tf_trans)

# output:

# [[[ 1  4]
#   [ 2  5]
#   [ 3  6]]
#
#  [[ 7 10]
#   [ 8 11]
#   [ 9 12]]]

################################
# tf.matmul
################################
# 2-D tensor `a`
a = tf.constant([1, 2, 3, 4, 5, 6], shape=[2, 3])
# 2-D tensor `b`
b = tf.constant([7, 8, 9, 10, 11, 12], shape=[3, 2])
tf_matmul = tf.matmul(a, b)

print "tf.matmul"
print sess.run(tf_matmul)

# output:

# tf.matmul
# [[ 58  64]
#  [139 154]]

################################
# tf.matrix_determinant
################################
a = tf.constant([1., 2., 3., 4.], shape=[2, 2])
tf_determinant = tf.matrix_determinant(a)

print "tf.matrix_determinant"
print sess.run(tf_determinant)

# output:

# tf.matrix_determinant
# -2.0

################################
# tf.matrix_inverse
################################
a = tf.constant([1., 2., 3., 4.], shape=[2, 2])
tf_inverse = tf.matrix_inverse(a)

print "tf.matrix_inverse"
print sess.run(tf_inverse)

# output:

# tf.matrix_inverse
# [[-2.00000024  1.00000012]
#  [ 1.50000012 -0.50000006]]

################################
# tf.batch_matmul
# tf.batch_matrix_determinant
# tf.batch_matrix_inverse
################################
# 行列スライスについて調査中

################################
# tf.cholesky
# tf.batch_cholesky
################################
# コレスキー分解について調査中

################################
# tf.self_adjoint_eig
# tf.batch_self_adjoint_eig
################################
# エルミート行列について調査中

sess.close()

4. 複素数関数

API機能
tf.complex(real, imag, name=None)実部/虚部から複素テンソルに変換
tf.complex_abs(x, name=None))複素数の絶対値(a+bj→√(a^+b^2))を計算
tf.conj(in_, name=None))複素共役(a+bj→a-bj)を返す
tf.imag(in_, name=None))複素数の虚部(a+bj→b)を返す
tf.real(in_, name=None))複素数の実部(a+bj→a)を返す

サンプルコード:

import tensorflow as tf

sess = tf.InteractiveSession()

################
# tf.complex
################
# tensor 'real' is [2.25, 3.25]
# tensor `imag` is [4.75, 5.75]
tf_complex = tf.complex([2.25, 3.25], [4.75, 5.75])

print "tf.complex"
print sess.run(tf_complex)

# output:

# tf.complex
# [ 2.25+4.75j  3.25+5.75j]

################
# tf.complex_abs
################
# tensor 'x' is [[-2.25 + 4.75j], [-3.25 + 5.75j]]
x = tf.complex([-2.25, -3.25], [4.75, 5.75])
tf_abs = tf.complex_abs(x)

print "tf.complex_abs"
print sess.run(tf_abs)

# output:

# tf.complex_abs
# [ 5.25594902  6.60492229]

################
# tf.conj
################
# tensor 'in' is [-2.25 + 4.75j, 3.25 + 5.75j]
x = tf.complex([-2.25, 3.25], [4.75, 5.75])
tf_conj = tf.conj(x)

print "tf.conj"
print sess.run(tf_conj)

# output:

# tf.conj
# [-2.25-4.75j  3.25-5.75j]

################
# tf.imag
################
# tensor 'in' is [-2.25 + 4.75j, 3.25 + 5.75j]
x = tf.complex([-2.25, 3.25], [4.75, 5.75])
tf_imag = tf.imag(x)

print "tf.imag"
print sess.run(tf_imag)

# output:

# tf.imag
# [ 4.75  5.75]

################
# tf.real
################
# tensor 'in' is [-2.25 + 4.75j, 3.25 + 5.75j]
x = tf.complex([-2.25, 3.25], [4.75, 5.75])
tf_real = tf.real(x)

print "tf.real"
print sess.run(tf_real)

# output:

# tf.real
# [-2.25  3.25]

sess.close()

5. テンソルの縮約

API機能
tf.reduce_sum(input_tensor, reduction_indices=None, keep_dims=False, name=None)Tensorの要素の和を計算
tf.reduce_prod(input_tensor, reduction_indices=None, keep_dims=False, name=None))Tensorの要素の積を計算
tf.reduce_min(input_tensor, reduction_indices=None, keep_dims=False, name=None))Tensorの要素の最小を計算
tf.reduce_max(input_tensor, reduction_indices=None, keep_dims=False, name=None))Tensorの要素の最大を計算
tf.reduce_mean(input_tensor, reduction_indices=None, keep_dims=False, name=None))Tensorの要素の平均を計算
tf.reduce_all(input_tensor, reduction_indices=None, keep_dims=False, name=None))Tensorの要素の論理積(and)を計算
tf.reduce_any(input_tensor, reduction_indices=None, keep_dims=False, name=None))Tensorの要素の論理和(or)を計算
tf.accumulate_n(inputs, shape=None, tensor_dtype=None, name=None))Tensorの要素ごとに総和を計算

サンプルコード:

import tensorflow as tf

sess = tf.InteractiveSession()

##################
# tf.reduce_sum
##################
# 'x' is [[1, 1, 1]]
#         [1, 1, 1]]
x = tf.constant([[1, 1, 1], [1, 1, 1]])
tf_rsum1 = tf.reduce_sum(x)
tf_rsum2 = tf.reduce_sum(x, 0)
tf_rsum3 = tf.reduce_sum(x, 1)
tf_rsum4 = tf.reduce_sum(x, 1, keep_dims=True)
tf_rsum5 = tf.reduce_sum(x, [0, 1])

print "tf.reduce_sum"
print sess.run(tf_rsum1)
print sess.run(tf_rsum2)
print sess.run(tf_rsum3)
print sess.run(tf_rsum4)
print sess.run(tf_rsum5)

# output:

# tf.reduce_sum
# 6
# [2 2 2]
# [3 3]
# [[3]
#  [3]]
# 6

##################
# tf.reduce_prod
##################
x = tf.constant([[1, 2, 3], [1, 2, 3]])
tf_rprod1 = tf.reduce_prod(x)
tf_rprod2 = tf.reduce_prod(x, 0)
tf_rprod3 = tf.reduce_prod(x, 1)
tf_rprod4 = tf.reduce_prod(x, 1, keep_dims=True)
tf_rprod5 = tf.reduce_prod(x, [0, 1])

print "tf.reduce_prod"
print sess.run(tf_rprod1)
print sess.run(tf_rprod2)
print sess.run(tf_rprod3)
print sess.run(tf_rprod4)
print sess.run(tf_rprod5)

# output:

# tf.reduce_prod
# 36
# [1 4 9]
# [6 6]
# [[6]
#  [6]]
# 36

##################
# tf.reduce_min
##################
x = tf.constant([[1, 2, 3], [1, 2, 3]])
tf_rmin1 = tf.reduce_min(x)
tf_rmin2 = tf.reduce_min(x, 0)
tf_rmin3 = tf.reduce_min(x, 1)
tf_rmin4 = tf.reduce_min(x, 1, keep_dims=True)
tf_rmin5 = tf.reduce_min(x, [0, 1])

print "tf.reduce_min"
print sess.run(tf_rmin1)
print sess.run(tf_rmin2)
print sess.run(tf_rmin3)
print sess.run(tf_rmin4)
print sess.run(tf_rmin5)

# output:

# tf.reduce_min
# 1
# [1 2 3]
# [1 1]
# [[1]
#  [1]]
# 1

##################
# tf.reduce_max
##################
x = tf.constant([[1, 2, 3], [1, 2, 3]])
tf_rmax1 = tf.reduce_max(x)
tf_rmax2 = tf.reduce_max(x, 0)
tf_rmax3 = tf.reduce_max(x, 1)
tf_rmax4 = tf.reduce_max(x, 1, keep_dims=True)
tf_rmax5 = tf.reduce_max(x, [0, 1])

print "tf.reduce_max"
print sess.run(tf_rmax1)
print sess.run(tf_rmax2)
print sess.run(tf_rmax3)
print sess.run(tf_rmax4)
print sess.run(tf_rmax5)

# output:

# tf.reduce_max
# 3
# [1 2 3]
# [3 3]
# [[3]
#  [3]]
# 3

##################
# tf.reduce_mean
##################
# 'x' is [[1., 1. ]]
#         [2., 2.]]
x = tf.constant([[1., 1.], [2., 2.]])
tf_rmean1 = tf.reduce_mean(x)
tf_rmean2 = tf.reduce_mean(x, 0)
tf_rmean3 = tf.reduce_mean(x, 1)

print "tf.reduce_mean"
print sess.run(tf_rmean1)
print sess.run(tf_rmean2)
print sess.run(tf_rmean3)

# output:

# tf.reduce_mean
# 1.5
# [ 1.5  1.5]
# [ 1.  2.]

##################
# tf.reduce_all
##################
# 'x' is [[True,  True]]
#         [False, False]]
x = tf.constant([[True, True], [False, False]])
tf_rall1 = tf.reduce_all(x)
tf_rall2 = tf.reduce_all(x, 0)
tf_rall3 = tf.reduce_all(x, 1)

print "tf.reduce_all"
print sess.run(tf_rall1)
print sess.run(tf_rall2)
print sess.run(tf_rall3)

# output:

# tf.reduce_all
# False
# [False False]
# [ True False]

##################
# tf.reduce_any
##################
# 'x' is [[True,  True]]
#         [False, False]]
x = tf.constant([[True, True], [False, False]])
tf_rany1 = tf.reduce_any(x)
tf_rany2 = tf.reduce_any(x, 0)
tf_rany3 = tf.reduce_any(x, 1)

print "tf.reduce_any"
print sess.run(tf_rany1)
print sess.run(tf_rany2)
print sess.run(tf_rany3)

# output:

# tf.reduce_any
# True
# [ True  True]
# [ True False]

##################
# tf.accumulate_n
##################
# tensor 'a' is [[1, 2], [3, 4]
# tensor `b` is [[5, 0], [0, 6]]
a = tf.constant([[1, 2], [3, 4]])
b = tf.constant([[5, 0], [0, 6]])
tf_accum1 = tf.accumulate_n([a, b, a])

# Explicitly pass shape and type
tf_accum2 = tf.accumulate_n([a, b, a], shape=[2, 2], tensor_dtype=tf.int32)

print "tf.accumulate_n"
print sess.run(tf_accum1)
print sess.run(tf_accum2)

# output:

# tf.accumulate_n
# [[ 7  4]
#  [ 6 14]]
# [[ 7  4]
#  [ 6 14]]

sess.close()

6. セグメント

API機能
tf.segment_sum(data, segment_ids, name=None)Tensorの各セグメントの和を計算
tf.segment_prod(data, segment_ids, name=None)Tensorの各セグメントの積を計算
tf.segment_min(data, segment_ids, name=None)Tensorの各セグメントの最小を計算
tf.segment_max(data, segment_ids, name=None)Tensorの各セグメントの最大を計算
tf.segment_mean(data, segment_ids, name=None)Tensorの各セグメントの平均を計算
tf.unsorted_segment_sum(data, segment_ids, num_segments, name=None)Tensorの各セグメントの和を計算
tf.sparse_segment_sum(data, indices, segment_ids, name=None)Tensorの選択したセグメントの和を計算
tf.sparse_segment_mean(data, indices, segment_ids, name=None)Tensorの選択したセグメントの平均を計算

import tensorflow as tf

sess = tf.InteractiveSession()

##########################
# tf.segment_sum
##########################
c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])
tf_sum = tf.segment_sum(c, tf.constant([0, 0, 1]))

print "tf.segment_sum"
print sess.run(tf_sum)

# output:

# tf.segment_sum
# [[0 0 0 0]
#  [5 6 7 8]]

##########################
# tf.segment_prod
##########################
c = tf.constant([[1,2,3,4], [1,2,3,4], [5,6,7,8]])
tf_prod = tf.segment_prod(c, tf.constant([0, 0, 1]))

print "tf.segment_prod"
print sess.run(tf_prod)

# output:

# tf.segment_prod
# [[ 1  4  9 16]
#  [ 5  6  7  8]]

##########################
# tf.segment_min
##########################
c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])
tf_min = tf.segment_min(c, tf.constant([0, 0, 1]))

print "tf.segment_min"
print sess.run(tf_min)

# output:

# tf.segment_min
# [[-1 -2 -3 -4]
#  [ 5  6  7  8]]

##########################
# tf.segment_max
##########################
c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])
tf_max = tf.segment_max(c, tf.constant([0, 0, 1]))

print "tf.segment_max"
print sess.run(tf_max)

# output:

# tf.segment_max
# [[1 2 3 4]
#  [5 6 7 8]]

##########################
# tf.segment_mean
##########################
c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])
tf_mean = tf.segment_mean(c, tf.constant([0, 0, 1]))

print "tf.segment_mean"
print sess.run(tf_mean)

# output:

# tf.segment_mean
# [[0 0 0 0]
#  [5 6 7 8]]

##########################
# tf.unsorted_segment_sum
##########################
c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])
tf_unsorted = tf.unsorted_segment_sum(c, tf.constant([1, 0, 0]), 2)

print "tf.unsorted_segment_sum"
print sess.run(tf_unsorted)

# output:

# tf.unsorted_segment_sum
# [[4 4 4 4]
#  [1 2 3 4]]

##########################
# tf.sparse_segment_sum
##########################
c = tf.constant([[1,2,3,4], [-1,-2,-3,-4], [5,6,7,8]])

# Select two rows, one segment.
tf_ssum1 = tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 0]))

# Select two rows, two segment.
tf_ssum2 = tf.sparse_segment_sum(c, tf.constant([0, 1]), tf.constant([0, 1]))

# Select all rows, two segments.
tf_ssum3 = tf.sparse_segment_sum(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))

print "tf.sparse_segment_sum"
print sess.run(tf_ssum1)
print sess.run(tf_ssum2)
print sess.run(tf_ssum3)

# output:

# tf.sparse_segment_sum
# [[0 0 0 0]]
# [[ 1  2  3  4]
#  [-1 -2 -3 -4]]
# [[0 0 0 0]
#  [5 6 7 8]]

##########################
# tf.sparse_segment_mean
##########################
c = tf.constant([[1.,2.,3.,4.], [-1.,-2.,-3.,-4.], [5.,6.,7.,8.]])
tf_smean1 = tf.sparse_segment_mean(c, tf.constant([0, 1]), tf.constant([0, 0]))
tf_smean2 = tf.sparse_segment_mean(c, tf.constant([0, 1]), tf.constant([0, 1]))
tf_smean3 = tf.sparse_segment_mean(c, tf.constant([0, 1, 2]), tf.constant([0, 0, 1]))

print "tf.sparse_segment_mean"
print sess.run(tf_smean1)
print sess.run(tf_smean2)
print sess.run(tf_smean3)

# output:

# tf.sparse_segment_mean
# [[ 0.  0.  0.  0.]]
# [[ 1.  2.  3.  4.]
#  [-1. -2. -3. -4.]]
# [[ 0.  0.  0.  0.]
#  [ 5.  6.  7.  8.]]

sess.close()

7. シーケンスの比較とインデックス



API機能
tf.argmin(input, dimension, name=None)Tensorの指定した階層の最小値のインデックスを返す
tf.argmax(input, dimension, name=None)Tensorの指定した階層の最大値のインデックスを返す
tf.listdiff(x, y, name=None)2つのリストの差を計算
tf.where(input, name=None)Boolean TensorのTrue位置を返す
tf.unique(x, name=None)1次元Tensorで重複のない要素を見つける
tf.edit_distance(hypothesis, truth, normalize=True, name=edit_distance)<.td>シーケンス間のレーベンシュタイン距離を計算
tf.invert_permutation(x, name=None)Tensorの逆置換を計算

サンプルコード:

import tensorflow as tf

sess = tf.InteractiveSession()

########################
# tf.argmin
########################
x = tf.constant([[1, 2, 3], [3, 2, 1]])
tf_argmin1 = tf.argmin(x, 0)
tf_argmin2 = tf.argmin(x, 1)

print "tf.argmin"
print sess.run(tf_argmin1)
print sess.run(tf_argmin2)

# output:

# tf.argmin
# [0 0 1]
# [0 2]

########################
# tf.argmax
########################
x = tf.constant([[1, 2, 3], [3, 2, 1]])
tf_argmax1 = tf.argmax(x, 0)
tf_argmax2 = tf.argmax(x, 1)

print "tf.argmax"
print sess.run(tf_argmax1)
print sess.run(tf_argmax2)

# output:

# tf.argmax
# [1 0 0]
# [2 0]

########################
# tf.listdiff
########################
x = tf.constant([1, 2, 3, 4, 5, 6])
y = tf.constant([1, 3, 5])

out, idx = tf.listdiff(x, y)

print "tf.listdiff"
print sess.run(out)
print sess.run(idx)

# output:

# tf.listdiff
# [2 4 6]
# [1 3 5]

########################
# tf.where
########################
# '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.
input = tf.constant([[True, False], [True, False]])
tf_where1 = tf.where(input)

# `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.
input = tf.constant([[[True, False], [True, False]],
                     [[False, True], [False, True]],
                     [[False, False], [False, True]]])
tf_where2 = tf.where(input)

print "tf.where"
print sess.run(tf_where1)
print sess.run(tf_where2)

# output:

# tf.where
# [[0 0]
#  [1 0]]
# [[0 0 0]
#  [0 1 0]
#  [1 0 1]
#  [1 1 1]
#  [2 1 1]]

########################
# tf.unique
########################
x = tf.constant([1, 1, 2, 4, 4, 4, 7, 8, 8])
y, idx = tf.unique(x)

print "tf.unique"
print sess.run(y)
print sess.run(idx)

# output:

# tf.unique
# [1 2 4 7 8]
# [0 0 1 2 2 2 3 4 4]

########################
# tf.edit_distance
########################
# 'hypothesis' is a tensor of shape `[2, 1]` with variable-length values:
#   (0,0) = ["a"]
#   (1,0) = ["b"]
hypothesis = tf.SparseTensor(
    indices = tf.constant([[0, 0, 0], [1, 0, 0]], "int64"),
    values = ["a", "b"], 
    shape = tf.constant([2, 1, 1], "int64"))

# '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(
    indices = tf.constant([[0, 1, 0], [1, 0, 0], [1, 0, 1], [1, 1, 0]], "int64"),
    values = ["a", "b", "c", "a"],
    shape = tf.constant([2, 2, 2], "int64"))

tf_edit_dist = tf.edit_distance(hypothesis, truth, True)

print "tf.edit_distance"
print sess.run(tf_edit_dist)

# output:

# tf.edit_distance
# [[ inf  1. ]
#  [ 0.5  1. ]]

########################
# tf.invert_permutation
########################
# tensor `x` is [3, 4, 0, 2, 1]
x = tf.constant([3, 4, 0, 2, 1])
tf_invert = tf.invert_permutation(x)

print "tf.invert_permutation"
print sess.run(tf_invert)

# output:
# tf.invert_permutation
# [2 4 3 0 1]

sess.close()

やばい, やばい.
長いこと線形代数使うことなかったので, かなり忘れている.

----
参照URL:
[1] Math | TensorFlow





AIの衝撃 人工知能は人類の敵か (講談社現代新書)

AIの衝撃 人工知能は人類の敵か (講談社現代新書)



人工知能、ロボット、人の心。 (TheWave出版)

人工知能、ロボット、人の心。 (TheWave出版)