An array has at least one maximum element . in its simplest case gives the index of this maximum element, so that . The Tensorflow argmax requires you to designate one dimension of your tensor to act as that array.

import tensorflow as tf
sess = tf . InteractiveSession ()
# Since x[3] is the largest number(4), argmax(x) is 3
x = [ 1 , 2 , 3 , 4 , 3 , 2 , 1 ]
tf . argmax ( x , axis = 0 ) . eval ()
# 3
# Axis 1 will apply argmax to the rows
# Axis 0 will apply argmax to the columns
x = [[ 1 , 2 , 3 , 4 , 3 , 2 , 1 ],
[ 2 , 3 , 4 , 3 , 2 , 1 , 0 ]]
tf . argmax ( x , axis = 0 ) . eval ()
# [3,2]
tf . argmax ( x , axis = 1 ) . eval
# [1,1,1,0,0,0,0]

Once you have some indices, you can convert them to values using gather. gather in its simplest case is equivalent to doing an array lookup: .

import tensorflow as tf
sess = tf . InteractiveSession
# A scalar index of a vector is a scalar.
# 3 is the index of 4, so gathering 3 is 4.
x = [ 1 , 2 , 3 , 4 , 3 , 2 , 1 ]
tf . gather ( x , 3 ) . eval ()
# 4
# A scalar index of a matrix x is a vector.
# Row 0 of x is [1,2,3,4,3,2,1], so gathering 0 returns it.
x = [[ 1 , 2 , 3 , 4 , 3 , 2 , 1 ],
[ 2 , 3 , 4 , 3 , 2 , 1 , 0 ]]
tf . gather ( x , 0 ) . eval ()
# [1,2,3,4, 3, 2, 1]
# Gathering a vector index produces a scalar index for each element of the vector, and then concatenates them.
# Gathering [1,0] produces row 1 and row 0. Concatenating them flips the rows in the original matrix.
tf . gather ( x , [ 1 , 0 ]) . eval ()
# [[ 2,3,4,3,2,1,0],
[ 1 , 2 , 3 , 4 , 3 , 2 , 1 ]]
# In general, each scalar index within the index tensor will produce an entire row in x.
tf . gather ( x , [[[ 1 ]],[[ 0 ]]]) . eval ()
# [[[2,3,4,3,2,1,0]],
[[ 1 , 2 , 3 , 4 , 3 , 2 , 1 ]]]

gather assumes that each scalar is an index along the first dimension. You can use gather_nd to target other values:

import tensorflow as tf
sess = tf . InteractiveSession ()
x = [[ 1 , 2 , 3 , 4 , 3 , 2 , 1 ],
[ 2 , 3 , 4 , 3 , 2 , 1 , 0 ]]
# An empty index returns the entire tensor.
i = tf . cast ([], tf . int32 )
tf . gather_nd ( x , i ) . eval ()
# [[ 1,2,3,4,3,2,1],
# [ 2,3,4,3,2,1,0]]
# The row 0 of x is [1,2,3,4,3,2,1], so gathering [0] returns it.
tf . gather_nd ( x , [ 0 ]) . eval ()
# [1,2,3,4,3,2,1]
# Row 0, column 0 of x is 1, so gathering [0,0] returns 1.
tf . gather_nd ( x , [ 0 , 0 ]) . eval ()
# 1
# The last dimension(or the most deeply-nested list) of the index tensor is an index vector using the previous rules.
# So if we stack two copies of the previous index tensors, we'll get two copies of the result:
# Two empty indices return two copies of the entire tensor
i = tf . cast ([[],[]], tf . int32 )
tf . gather_nd ( x , i ) . eval ()
# [[[ 1,2,3,4,3,2,1],
# [ 2,3,4,3,2,1,0]],
# [[ 1,2,3,4,3,2,1],
# [ 2,3,4,3,2,1,0]]]
# Gathering [0] twice returns the first row twice.
tf . gather_nd ( x , [[ 0 ],[ 0 ]]) . eval ()
# [[1,2,3,4,3,2,1],
[ 1 , 2 , 3 , 4 , 3 , 2 , 1 ]]
# Gathering [0,0] twice returns row 0, col 0 twice:
tf . gather_nd ( x , [[ 0 , 0 ],[ 0 , 0 ]]) . eval ()
# [1,1]

You should know the rules for all three functions now. As a homework assignment, open a python session and fill in the below puzzle to make the assertion pass:

Handy Tools for working with indices:

import tensorflow as tf
sess = tf . InteractiveSession ()
# x is a random rgb color image.
x = tf . random_uniform ([ 32 , 32 , 3 ], maxval = 255 , dtype = tf . int32 ) . eval ()
# Use argmax to calculate which color has the largest value. Shape = [32, 32]
indices = ???
# Use meshgrid and stack to generate coordinates for dimensions except the color, and then add our color indices to the end. Shape = [32, 32, 3]
coords = ???
# Select only that largest color using gather_nd to "greyscale" the image. Shape = [32, 32]
y = ???
# Write both images to disk so you can compare.
tf . write_file ( "original.png" , tf . image . encode_png ( x )) . run ()
tf . write_file ( "greyscale.png" , tf . image . encode_png ( y )) . run ()

If you get stuck, see the solution below:

import tensorflow as tf
sess = tf . InteractiveSession ()
# x is a random rgb color image.
x = tf . random_uniform ([ 32 , 32 , 3 ], maxval = 255 , dtype = tf . int32 ) . eval ()
# Use argmax to calculate which color has the largest value
indices = tf . argmax ( x , axis = 2 ) . eval ()
# Use meshgrid and stack to generate coordinates for dimensions except the color, and then add our color indices to the end.
coords = tf . stack ( tf . meshgrid ( tf . range ( 0 , 32 ), tf . range ( 0 , 32 )) + [ indices ], axis = 2 ) . eval ()
# Select only that largest color using gather_nd to "greyscale" the image
y = tf . gather_nd ( x , coords ) . eval ()
# Write both images to disk so you can compare.
tf . write_file ( "original.png" , tf . image . encode_png ( x )) . run ()
grey = tf . cast ( tf . reshape ( y , [ 32 , 32 , 1 ]), tf . uint8 )
tf . write_file ( "greyscale.png" , tf . image . encode_png ( grey )) . run ()

Michael Burge helps companies efficiently process their large datasets. This includes everything from database and schema design for new projects, problem diagnosis and repair for existing projects hitting scaling limits, and even bespoke SQL compilers and databases for exceptionally difficult cases. Hire Michael to benefit from his extensive knowledge and experience.