Tensor Manipulation¶

In [ ]:

# https://www.tensorflow.org/api_guides/python/array_ops
import tensorflow as tf
import numpy as np
import pprint
tf.set_random_seed(777)  # for reproducibility

pp = pprint.PrettyPrinter(indent=4)
sess = tf.InteractiveSession()

Simple Array¶

In [55]:

t = np.array([0., 1., 2., 3., 4., 5., 6.])
pp.pprint(t)
print(t.ndim) # rank
print(t.shape) # shape
print(t[0], t[1], t[-1])
print(t[2:5], t[4:-1])
print(t[:2], t[3:])

array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.])
(7,) 1
0.0 1.0 6.0
[ 2.  3.  4.] [ 4.  5.]
[ 0.  1.] [ 3.  4.  5.  6.]

2D Array¶

In [58]:

t = np.array([[1., 2., 3.], [4., 5., 6.], [7., 8., 9.], [10., 11., 12.]])
pp.pprint(t)
print(t.ndim) # rank
print(t.shape) # shape

array([[  1.,   2.,   3.],
       [  4.,   5.,   6.],
       [  7.,   8.,   9.],
       [ 10.,  11.,  12.]])
2
(4, 3)

Shape, Rank, Axis¶

In [5]:

t = tf.constant([1,2,3,4])
tf.shape(t).eval()

Out[5]:

array([4], dtype=int32)

In [6]:

t = tf.constant([[1,2],
                 [3,4]])
tf.shape(t).eval()

Out[6]:

array([2, 2], dtype=int32)

In [60]:

t = tf.constant([[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]],[[13, 14, 15, 16], [17, 18, 19, 20], [21, 22, 23, 24]]]])
tf.shape(t).eval()

Out[60]:

array([1, 2, 3, 4], dtype=int32)

In [8]:

[
    [
        [
            [1,2,3,4], 
            [5,6,7,8],
            [9,10,11,12]
        ],
        [
            [13,14,15,16],
            [17,18,19,20], 
            [21,22,23,24]
        ]
    ]
]

Out[8]:

[[[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]],
  [[13, 14, 15, 16], [17, 18, 19, 20], [21, 22, 23, 24]]]]

Matmul VS multiply¶

In [9]:

matrix1 = tf.constant([[3., 3.]])
matrix2 = tf.constant([[2.],[2.]])
tf.matmul(matrix1, matrix2).eval()

Out[9]:

array([[ 12.]], dtype=float32)

In [10]:

(matrix1*matrix2).eval()

Out[10]:

array([[ 6.,  6.],
       [ 6.,  6.]], dtype=float32)

Watch out broadcasting¶

In [11]:

matrix1 = tf.constant([[3., 3.]])
matrix2 = tf.constant([[2.],[2.]])
(matrix1+matrix2).eval()

Out[11]:

array([[ 5.,  5.],
       [ 5.,  5.]], dtype=float32)

In [12]:

matrix1 = tf.constant([[3., 3.]])
matrix2 = tf.constant([[2., 2.]])
(matrix1+matrix2).eval()

Out[12]:

array([[ 5.,  5.]], dtype=float32)

Random values for variable initializations¶

In [2]:

tf.random_normal([3]).eval()

Out[2]:

array([ 2.20866942, -0.73225045,  0.33533147], dtype=float32)

In [3]:

tf.random_uniform([2]).eval()

Out[3]:

array([ 0.08186948,  0.42999184], dtype=float32)

In [4]:

tf.random_uniform([2, 3]).eval()

Out[4]:

array([[ 0.43535876,  0.76933432,  0.65130949],
       [ 0.90863407,  0.06278825,  0.85073185]], dtype=float32)

Reduce Mean/Sum¶

In [13]:

tf.reduce_mean([1, 2], axis=0).eval()

Out[13]:

In [14]:

x = [[1., 2.],
     [3., 4.]]


tf.reduce_mean(x).eval()

Out[14]:

2.5

In [15]:

tf.reduce_mean(x, axis=0).eval()

Out[15]:

array([ 2.,  3.], dtype=float32)

In [16]:

tf.reduce_mean(x, axis=1).eval()

Out[16]:

array([ 1.5,  3.5], dtype=float32)

In [17]:

tf.reduce_mean(x, axis=-1).eval()

Out[17]:

array([ 1.5,  3.5], dtype=float32)

In [18]:

tf.reduce_sum(x).eval()

Out[18]:

10.0

In [19]:

tf.reduce_sum(x, axis=0).eval()

Out[19]:

array([ 4.,  6.], dtype=float32)

In [20]:

tf.reduce_sum(x, axis=-1).eval()

Out[20]:

array([ 3.,  7.], dtype=float32)

In [21]:

tf.reduce_mean(tf.reduce_sum(x, axis=-1)).eval()

Out[21]:

5.0

Argmax with axis¶

In [22]:

x = [[0, 1, 2],
     [2, 1, 0]]
tf.argmax(x, axis=0).eval()

Out[22]:

array([1, 0, 0])

In [23]:

tf.argmax(x, axis=1).eval()

Out[23]:

array([2, 0])

In [24]:

tf.argmax(x, axis=-1).eval()

Out[24]:

array([2, 0])

Reshape, squeeze, expand_dims¶

In [25]:

t = np.array([[[0, 1, 2], 
               [3, 4, 5]],
              
              [[6, 7, 8], 
               [9, 10, 11]]])
t.shape

Out[25]:

(2, 2, 3)

In [26]:

tf.reshape(t, shape=[-1, 3]).eval()

Out[26]:

array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 9, 10, 11]])

In [27]:

tf.reshape(t, shape=[-1, 1, 3]).eval()

Out[27]:

array([[[ 0,  1,  2]],

       [[ 3,  4,  5]],

       [[ 6,  7,  8]],

       [[ 9, 10, 11]]])

In [28]:

tf.squeeze([[0], [1], [2]]).eval()

Out[28]:

array([0, 1, 2], dtype=int32)

In [29]:

tf.expand_dims([0, 1, 2], 1).eval()

Out[29]:

array([[0],
       [1],
       [2]], dtype=int32)

One hot¶

In [30]:

tf.one_hot([[0], [1], [2], [0]], depth=3).eval()

Out[30]:

array([[[ 1.,  0.,  0.]],

       [[ 0.,  1.,  0.]],

       [[ 0.,  0.,  1.]],

       [[ 1.,  0.,  0.]]], dtype=float32)

In [31]:

t = tf.one_hot([[0], [1], [2], [0]], depth=3)
tf.reshape(t, shape=[-1, 3]).eval()

Out[31]:

array([[ 1.,  0.,  0.],
       [ 0.,  1.,  0.],
       [ 0.,  0.,  1.],
       [ 1.,  0.,  0.]], dtype=float32)

casting¶

In [32]:

tf.cast([1.8, 2.2, 3.3, 4.9], tf.int32).eval()

Out[32]:

array([1, 2, 3, 4], dtype=int32)

In [33]:

tf.cast([True, False, 1 == 1, 0 == 1], tf.int32).eval()

Out[33]:

array([1, 0, 1, 0], dtype=int32)

Stack¶

In [34]:

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

# Pack along first dim.
tf.stack([x, y, z]).eval()

Out[34]:

array([[1, 4],
       [2, 5],
       [3, 6]], dtype=int32)

In [35]:

tf.stack([x, y, z], axis=1).eval()

Out[35]:

array([[1, 2, 3],
       [4, 5, 6]], dtype=int32)

Ones like and Zeros like¶

In [36]:

x = [[0, 1, 2],
     [2, 1, 0]]

tf.ones_like(x).eval()

Out[36]:

array([[1, 1, 1],
       [1, 1, 1]], dtype=int32)

In [37]:

tf.zeros_like(x).eval()

Out[37]:

array([[0, 0, 0],
       [0, 0, 0]], dtype=int32)

Zip¶

In [38]:

for x, y in zip([1, 2, 3], [4, 5, 6]):
    print(x, y)

1 4
2 5
3 6

In [39]:

for x, y, z in zip([1, 2, 3], [4, 5, 6], [7, 8, 9]):
    print(x, y, z)

1 4 7
2 5 8
3 6 9

Transpose¶

In [40]:

t = np.array([[[0, 1, 2], [3, 4, 5]], [[6, 7, 8], [9, 10, 11]]])
pp.pprint(t.shape)
pp.pprint(t)

(2, 2, 3)
array([[[ 0,  1,  2],
        [ 3,  4,  5]],

       [[ 6,  7,  8],
        [ 9, 10, 11]]])

In [41]:

t1 = tf.transpose(t, [1, 0, 2])
pp.pprint(sess.run(t1).shape)
pp.pprint(sess.run(t1))

(2, 2, 3)
array([[[ 0,  1,  2],
        [ 6,  7,  8]],

       [[ 3,  4,  5],
        [ 9, 10, 11]]])

In [42]:

t = tf.transpose(t1, [1, 0, 2])
pp.pprint(sess.run(t).shape)
pp.pprint(sess.run(t))

(2, 2, 3)
array([[[ 0,  1,  2],
        [ 3,  4,  5]],

       [[ 6,  7,  8],
        [ 9, 10, 11]]])

In [43]:

t2 = tf.transpose(t, [1, 2, 0])
pp.pprint(sess.run(t2).shape)
pp.pprint(sess.run(t2))

(2, 3, 2)
array([[[ 0,  6],
        [ 1,  7],
        [ 2,  8]],

       [[ 3,  9],
        [ 4, 10],
        [ 5, 11]]])

In [44]:

t = tf.transpose(t2, [2, 0, 1])
pp.pprint(sess.run(t).shape)
pp.pprint(sess.run(t))

(2, 2, 3)
array([[[ 0,  1,  2],
        [ 3,  4,  5]],

       [[ 6,  7,  8],
        [ 9, 10, 11]]])