1. tf.reduce_prod


: 행렬이 있을 때 특정 row 혹은 column에 있는 원소들을 다 곱하는 연산이다. reduce_mean의 곱하기 버젼이다. 물론 rank를 줄이기 때문에 reduce가 붙어있다. 


sess = tf.Session()

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

x_rsh = tf.reshape(x,(-1,2))

x_mul = tf.reduce_prod(x_rsh,axis=1)


print sess.run(x)

print sess.run(x_rsh)

print sess.run(x_mul)

[1 2 3 4 5 6]

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

[ 2 12 30]



2. kron


: 이건 tf.tile이랑 비슷하지만, [a,b]를 [a,b,a,b]로 만들어주는 tile에 비해서 [a,a,b,b]로 만들어준다. 단위행렬과 하는 크로너커 프로덕트랑 비슷해서 kron이라고 붙였다. 


def kron(_x, _k):

    _h = tf.shape(_x)[0]

    _w = tf.shape(_x)[1]

    return tf.reshape(tf.tile(tf.expand_dims(_x, axis=2), [1, 1, _k]), [_h, _w*_k])

y = tf.constant([[1,2]])

y_kron = kron(y,2)

z = tf.constant([[1,2],[3,4]])

z_kron = kron(z,2)


print sess.run(y)

print sess.run(y_kron)

print sess.run(z)

print sess.run(z_kron)

[[1 2]]

[[1 1 2 2]]

[[1 2]
 [3 4]]

[[1 1 2 2] 

[3 3 4 4]]



3. tf_normal


: 각 엘레멘트 별로 가우시안의 확률을 찾는 것이다. 


def tf_normal(_y,_mu,_sigma,_eps=0):

    _result = (_y-_mu)/_sigma

    _result = -tf.square(_result)/2

    eps     = _eps

    _result = tf.exp(_result)/(tf.sqrt(2*math.pi)*(_sigma+eps))    

    return _result    

sess = tf.Session()

y = tf.constant([[1,2,3,4,5,6]],dtype=tf.float32) 

mu = tf.constant(0,shape=[1,6],dtype=tf.float32) 

sigma = tf.constant(1,shape=[1,6],dtype=tf.float32)

probs = tf_normal(y,mu,sigma)


print sess.run(y)

print sess.run(mu)

print sess.run(sigma)

print sess.run(probs)

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

[[ 0.  0.  0.  0.  0.  0.]]

[[ 1.  1.  1.  1.  1.  1.]]

[[  2.41970733e-01   5.39909676e-02   4.43184841e-03   1.33830225e-04 

1.48671950e-06 6.07588246e-09]]



4. tf.nn.softmax


: Softmax를 취한다. 여기서 중요한 점은 softmax는 안에 들어가는 값들의 전체적인 bias에는 무관하다.

 

sess   = tf.Session()

pi1    = tf.constant([[1,2,3,4],[5,6,7,8]],dtype=tf.float32) 

pi2    = pi1 - tf.reshape(tf.reduce_max(pi1,axis=1),shape=(-1,1))

pi1_sm = tf.nn.softmax(pi1,dim=1)

pi2_sm = tf.nn.softmax(pi2,dim=1)


print sess.run(pi1)

print sess.run(pi2)

print sess.run(pi1_sm)

print sess.run(pi2_sm)

[[ 1.  2.  3.  4.]
 [ 5.  6.  7.  8.]]

[[-3. -2. -1.  0.]
 [-3. -2. -1.  0.]]

[[ 0.0320586   0.08714432  0.23688281  0.64391422]
 [ 0.0320586   0.08714432  0.23688281  0.64391422]]

[[ 0.0320586   0.08714432  0.23688281  0.64391422] 

[ 0.0320586 0.08714432 0.23688281 0.64391422]]



5. invkronprod


: Inverse Kronocker product라는 굉장히 애매한 이름인데 아래와 같이 동작되길 바라는 함수이다. 

[[1,2,3,4],[5,6,7,8]]와 2 => [[1*2,3*4],[5*6,7*8]]

[[1,2,3,4],[5,6,7,8]]와 4 => [[1*2*3*4],[5*6*7*8]]


def invkronprod(_x,_k=2):

    _h,_w = tf.shape(_x)[0],tf.shape(_x)[1]

    _x2 = tf.expand_dims(_x,axis=2)

    _x3 = tf.reshape(_x2,shape=[_h,_w/_k,-1])

    _x4 = tf.reduce_prod(_x3,axis=2)

    return _x4

sess = tf.Session()

x = tf.constant([[1,2,3,4,5,6],[7,8,9,10,11,12]],dtype=tf.float32)

x2 = invkronprod(x,_k=2)

x3 = invkronprod(x,_k=3)

    

print 'x:\n',sess.run(x)

print x

print 'x2:\n',sess.run(x2)

print x2

print 'x3:\n',sess.run(x3)

print x3

x:
[[  1.   2.   3.   4.   5.   6.]
 [  7.   8.   9.  10.  11.  12.]]
Tensor("Const_2:0", shape=(2, 6), dtype=float32)

x2:
[[   2.   12.   30.]
 [  56.   90.  132.]]
Tensor("Prod_4:0", shape=(?, ?), dtype=float32)

x3:
[[    6.   120.]
 [  504.  1320.]] 

Tensor("Prod_5:0", shape=(?, ?), dtype=float32)



6. Save & load network weights


: tf에서 제공하는 saver를 사용하지 않고 네트워크 파라미터를 npz로 저장하고 불러오기를 구현해보자. 


"""

    Construct CNN

"""

def build_model(self):

    self.x = tf.placeholder(dtype=tf.float32,shape=[None,self.xdim])

    self.y = tf.placeholder(dtype=tf.float32,shape=[None,self.nclass])

    self.is_training = tf.placeholder(dtype=tf.bool,shape=[])

    self.x_rshp = tf.reshape(self.x, [-1,self.xshp[0],self.xshp[1],1])

    bnparam = {'is_training':self.is_training,'decay':0.9,'updates_collections':None}

    self.winit = tf.truncated_normal_initializer(stddev=0.01)

    with tf.variable_scope('W') as scope:

        self.net = slim.conv2d(self.x_rshp,64,[3,3],padding='SAME',

                               activation_fn=tf.nn.relu,

                               weights_initializer=self.winit,

                               normalizer_fn=slim.batch_norm,

                               normalizer_params=bnparam,

                               scope='conv1')

        self.net = slim.max_pool2d(self.net, [2, 2], scope='pool1')

        self.net = slim.conv2d(self.net,128,[3,3],padding='SAME',

                               activation_fn=tf.nn.relu,

                               weights_initializer=self.winit,

                               normalizer_fn=slim.batch_norm,

                               normalizer_params=bnparam,

                               scope='conv2')

g_vars = tf.global_variables()

        self.g_vars = [var for var in g_vars if 'W/' in var.name]

"""

    Save

"""

def save(self,_savename=None):

    """ Save name """

    if _savename==None:

        _savename='net/net_cnn.npz'

    """ Get global variables """

    g_wnames,g_wvals = [],[]

    for i in range(len(self.g_vars)):

        curr_wname = self.g_vars[i].name

        curr_wvar  = [v for v in tf.global_variables() if v.name==curr_wname][0]

        curr_wval  = self.sess.run(curr_wvar)

        g_wnames.append(curr_wname)

        g_wvals.append(curr_wval)

    """ Save """

    np.savez(_savename,g_wnames=g_wnames,g_wvals=g_wvals)

    print ("[%s] Saved. Size is [%.1f]MB" % 

           (_savename,os.path.getsize(_savename)/1000./1000.))

"""

    Restore

"""

def restore(self,_loadname=None):

    if _loadname==None:

        _loadname='net/net_cnn.npz'

    l = np.load(_loadname)

    g_wnames = l['g_wnames']

    g_wvals  = l['g_wvals']

    for widx,wname in enumerate(g_wnames):

        curr_wvar  = [v for v in tf.global_variables() if v.name==wname][0]

        self.sess.run(tf.assign(curr_wvar,g_wvals[widx]))

    print ("Weight restored from [%s]" % (_loadname))

























« PREV : 1 : ··· : 21 : 22 : 23 : 24 : 25 : 26 : 27 : 28 : 29 : ··· : 620 : NEXT »