def testRecoverSession(self): # Create a checkpoint. checkpoint_dir = os.path.join(self.get_temp_dir(), "recover_session") try: gfile.DeleteRecursively(checkpoint_dir) except OSError: pass # Ignore gfile.MakeDirs(checkpoint_dir) with tf.Graph().as_default(): v = tf.Variable(1, name="v") sm = tf.train.SessionManager(ready_op=tf.assert_variables_initialized()) saver = tf.train.Saver({"v": v}) sess, initialized = sm.recover_session("", saver=saver, checkpoint_dir=checkpoint_dir) self.assertFalse(initialized) sess.run(v.initializer) self.assertEquals(1, sess.run(v)) saver.save(sess, os.path.join(checkpoint_dir, "recover_session_checkpoint")) # Create a new Graph and SessionManager and recover. with tf.Graph().as_default(): v = tf.Variable(2, name="v") sm2 = tf.train.SessionManager(ready_op=tf.assert_variables_initialized()) saver = tf.train.Saver({"v": v}) sess, initialized = sm2.recover_session("", saver=saver, checkpoint_dir=checkpoint_dir) self.assertTrue(initialized) self.assertEquals(1, sess.run(v))
def fc_wn(x, num_units, nonlinearity=None, init_scale=1., counters={}, init=False, ema=None, **kwargs): ''' fully connected layer ''' name = get_name('dense', counters) with tf.variable_scope(name): if init: # data based initialization of parameters V = tf.get_variable('V', [int(x.get_shape()[1]), num_units], tf.float32, tf.random_normal_initializer(0, 0.05), trainable=True) V_norm = tf.nn.l2_normalize(V.initialized_value(), [0]) x_init = tf.matmul(x, V_norm) m_init, v_init = tf.nn.moments(x_init, [0]) scale_init = init_scale / tf.sqrt(v_init + 1e-10) g = tf.get_variable('g', dtype=tf.float32, initializer=scale_init, trainable=True) b = tf.get_variable('b', dtype=tf.float32, initializer=-m_init * scale_init, trainable=True) x_init = tf.reshape(scale_init, [1, num_units]) * (x_init - tf.reshape(m_init, [1, num_units])) if nonlinearity is not None: x_init = nonlinearity(x_init) return x_init else: V, g, b = get_vars_maybe_avg(['V', 'g', 'b'], ema) tf.assert_variables_initialized([V, g, b]) # use weight normalization (Salimans & Kingma, 2016) x = tf.matmul(x, V) scaler = g / tf.sqrt(tf.reduce_sum(tf.square(V), [0])) x = tf.reshape(scaler, [1, num_units]) * x + tf.reshape(b, [1, num_units]) # apply nonlinearity if nonlinearity is not None: x = nonlinearity(x) return x
def testRecoverSession(self): # Create a checkpoint. checkpoint_dir = os.path.join(self.get_temp_dir(), "recover_session") try: gfile.DeleteRecursively(checkpoint_dir) except OSError: pass # Ignore gfile.MakeDirs(checkpoint_dir) with tf.Graph().as_default(): v = tf.Variable(1, name="v") sm = tf.train.SessionManager(ready_op=tf.assert_variables_initialized()) saver = tf.train.Saver({"v": v}) sess, initialized = sm.recover_session("", saver=saver, checkpoint_dir=checkpoint_dir) self.assertFalse(initialized) sess.run(v.initializer) self.assertEquals(1, sess.run(v)) saver.save(sess, os.path.join(checkpoint_dir, "recover_session_checkpoint")) # Create a new Graph and SessionManager and recover. with tf.Graph().as_default(): v = tf.Variable(2, name="v") with self.test_session(): self.assertEqual(False, tf.is_variable_initialized(v).eval()) sm2 = tf.train.SessionManager(ready_op=tf.assert_variables_initialized()) saver = tf.train.Saver({"v": v}) sess, initialized = sm2.recover_session("", saver=saver, checkpoint_dir=checkpoint_dir) self.assertTrue(initialized) self.assertEqual(True, tf.is_variable_initialized(sess.graph.get_tensor_by_name("v:0")).eval(session=sess)) self.assertEquals(1, sess.run(v))
def deconv(inp, name, filter_size, out_channels, stride=1, padding='SAME', nonlinearity=None, init_scale=1.0): """ Deconvolution layer. See `conv`""" with tf.variable_scope(name): strides = [1, stride, stride, 1] [N, H, W, in_channels] = inp.get_shape().as_list() if padding == 'SAME': target_shape = [N, H * stride, W * stride, out_channels] else: target_shape = [N, H * stride + filter_size[0] - 1, W * stride + filter_size[1] - 1, out_channels] target_shape = tf.constant(target_shape, dtype=tf.int32) if tf.GLOBAL['init']: V = get_variable('V', shape=filter_size + (out_channels, in_channels), dtype=tf.float32, initializer=tf.random_normal_initializer(0, 0.05), trainable=True) V_norm = tf.nn.l2_normalize(V.initialized_value(), [0, 1, 3]) out = tf.nn.conv2d_transpose(inp, V_norm, target_shape, strides, padding) m_init, v_init = tf.nn.moments(out, [0, 1, 2]) scale_init = init_scale / tf.sqrt(v_init + 1e-8) g = get_variable('g', shape=None, dtype=tf.float32, initializer=scale_init, trainable=True, regularizer=tf.contrib.layers.l2_regularizer(tf.GLOBAL['reg'])) b = get_variable('b', shape=None, dtype=tf.float32, initializer=-m_init * scale_init, trainable=True, regularizer=tf.contrib.layers.l2_regularizer(tf.GLOBAL['reg'])) out = tf.reshape(scale_init, [1, 1, 1, out_channels]) * (out - tf.reshape(m_init, [1, 1, 1, out_channels])) if nonlinearity is not None: out = nonlinearity(out) else: V, g, b = get_variable('V'), get_variable('g'), get_variable('b') tf.assert_variables_initialized([V, g, b]) W = g[None, None, :, None] * tf.nn.l2_normalize(V, [0, 1, 3]) out = tf.nn.conv2d_transpose(inp, W, target_shape, strides, padding) + b[None, None, None] if nonlinearity is not None: out = nonlinearity(out) return out
def weight_norm_linear(input_, output_size, init=False, init_scale=1.0, name="wn_linear", initializer=tf.truncated_normal_initializer, stddev=0.02): """Linear layer with Weight Normalization (Salimans, Kingma '16).""" with tf.variable_scope(name): if init: v = tf.get_variable("V", [int(input_.get_shape()[1]), output_size], tf.float32, initializer(0, stddev), trainable=True) v_norm = tf.nn.l2_normalize(v.initialized_value(), [0]) x_init = tf.matmul(input_, v_norm) m_init, v_init = tf.nn.moments(x_init, [0]) scale_init = init_scale / tf.sqrt(v_init + 1e-10) g = tf.get_variable("g", dtype=tf.float32, initializer=scale_init, trainable=True) b = tf.get_variable("b", dtype=tf.float32, initializer=-m_init*scale_init, trainable=True) x_init = tf.reshape(scale_init, [1, output_size]) * ( x_init - tf.reshape(m_init, [1, output_size])) return x_init else: v = tf.get_variable("V") g = tf.get_variable("g") b = tf.get_variable("b") tf.assert_variables_initialized([v, g, b]) x = tf.matmul(input_, v) scaler = g / tf.sqrt(tf.reduce_sum(tf.square(v), [0])) x = tf.reshape(scaler, [1, output_size]) * x + tf.reshape( b, [1, output_size]) return x
def weight_norm_conv2d(input_, output_dim, k_h, k_w, d_h, d_w, init, init_scale, stddev=0.02, name="wn_conv2d", initializer=tf.truncated_normal_initializer): """Convolution with Weight Normalization (Salimans, Kingma '16).""" with tf.variable_scope(name): if init: v = tf.get_variable( "V", [k_h, k_w] + [int(input_.get_shape()[-1]), output_dim], tf.float32, initializer(0, stddev), trainable=True) v_norm = tf.nn.l2_normalize(v.initialized_value(), [0, 1, 2]) x_init = tf.nn.conv2d(input_, v_norm, strides=[1, d_h, d_w, 1], padding="SAME") m_init, v_init = tf.nn.moments(x_init, [0, 1, 2]) scale_init = init_scale / tf.sqrt(v_init + 1e-8) g = tf.get_variable( "g", dtype=tf.float32, initializer=scale_init, trainable=True) b = tf.get_variable( "b", dtype=tf.float32, initializer=-m_init*scale_init, trainable=True) x_init = tf.reshape(scale_init, [1, 1, 1, output_dim]) * ( x_init - tf.reshape(m_init, [1, 1, 1, output_dim])) return x_init else: v = tf.get_variable("V") g = tf.get_variable("g") b = tf.get_variable("b") tf.assert_variables_initialized([v, g, b]) w = tf.reshape(g, [1, 1, 1, output_dim]) * tf.nn.l2_normalize( v, [0, 1, 2]) x = tf.nn.bias_add( tf.nn.conv2d(input_, w, [1, d_h, d_w, 1], padding="SAME"), b) return x
def conv2d(x, num_filters, filter_size=[3,3], stride=[1,1], pad='SAME', nonlinearity=None, init_scale=1., counters={}, init=False, ema=None, **kwargs): ''' convolutional layer ''' name = get_name('conv2d', counters) with tf.variable_scope(name): if init: # data based initialization of parameters V = tf.get_variable('V', filter_size+[int(x.get_shape()[-1]),num_filters], tf.float32, tf.random_normal_initializer(0, 0.05), trainable=True) V_norm = tf.nn.l2_normalize(V.initialized_value(), [0,1,2]) x_init = tf.nn.conv2d(x, V_norm, [1]+stride+[1], pad) m_init, v_init = tf.nn.moments(x_init, [0,1,2]) scale_init = init_scale/tf.sqrt(v_init + 1e-8) g = tf.get_variable('g', dtype=tf.float32, initializer=scale_init, trainable=True) b = tf.get_variable('b', dtype=tf.float32, initializer=-m_init*scale_init, trainable=True) x_init = tf.reshape(scale_init,[1,1,1,num_filters])*(x_init-tf.reshape(m_init,[1,1,1,num_filters])) if nonlinearity is not None: x_init = nonlinearity(x_init) return x_init else: V, g, b = get_vars_maybe_avg(['V', 'g', 'b'], ema) tf.assert_variables_initialized([V,g,b]) # use weight normalization (Salimans & Kingma, 2016) W = tf.reshape(g,[1,1,1,num_filters])*tf.nn.l2_normalize(V,[0,1,2]) # calculate convolutional layer output x = tf.nn.bias_add(tf.nn.conv2d(x, W, [1]+stride+[1], pad), b) # apply nonlinearity if nonlinearity is not None: x = nonlinearity(x) return x
def weight_norm(x): tf.assert_variables_initialized([V, g, b]) # use weight normalization (Salimans & Kingma, 2016) x = tf.matmul(x, V) scaler = g / tf.sqrt(tf.reduce_sum(tf.square(V), [0])) x = tf.reshape(scaler, [1, num_outputs]) * x + tf.reshape(b, [1, num_outputs]) return x, g, b
def testPrepareSessionFails(self): checkpoint_dir = os.path.join(self.get_temp_dir(), "prepare_session") checkpoint_dir2 = os.path.join(self.get_temp_dir(), "prepare_session2") try: gfile.DeleteRecursively(checkpoint_dir) gfile.DeleteRecursively(checkpoint_dir2) except errors.OpError: pass # Ignore gfile.MakeDirs(checkpoint_dir) with tf.Graph().as_default(): v = tf.Variable([1.0, 2.0, 3.0], name="v") sm = tf.train.SessionManager( ready_op=tf.assert_variables_initialized()) saver = tf.train.Saver({"v": v}) sess = sm.prepare_session("", init_op=tf.initialize_all_variables(), saver=saver, checkpoint_dir=checkpoint_dir) self.assertAllClose([1.0, 2.0, 3.0], sess.run(v)) checkpoint_filename = os.path.join(checkpoint_dir, "prepare_session_checkpoint") saver.save(sess, checkpoint_filename) # Create a new Graph and SessionManager and recover. with tf.Graph().as_default(): # Renames the checkpoint directory. os.rename(checkpoint_dir, checkpoint_dir2) gfile.MakeDirs(checkpoint_dir) v = tf.Variable([6.0, 7.0, 8.0], name="v") with self.test_session(): self.assertEqual(False, tf.is_variable_initialized(v).eval()) tf.train.SessionManager(ready_op=tf.assert_variables_initialized()) saver = tf.train.Saver({"v": v}) # This should fail as there's no checkpoint within 2 seconds. with self.assertRaisesRegexp( RuntimeError, "no init_op or init_fn or local_init_op was given"): sess = sm.prepare_session("", init_op=None, saver=saver, checkpoint_dir=checkpoint_dir, wait_for_checkpoint=True, max_wait_secs=2) # Rename the checkpoint directory back. gfile.DeleteRecursively(checkpoint_dir) os.rename(checkpoint_dir2, checkpoint_dir) # This should succeed as there's checkpoint. sess = sm.prepare_session("", init_op=None, saver=saver, checkpoint_dir=checkpoint_dir, wait_for_checkpoint=True, max_wait_secs=2) self.assertEqual( True, tf.is_variable_initialized( sess.graph.get_tensor_by_name("v:0")).eval(session=sess))
def weight_norm(x): tf.assert_variables_initialized([V, g, b]) # use weight normalization (Salimans & Kingma, 2016) W = tf.reshape(g, [1, 1, 1, num_outputs]) * tf.nn.l2_normalize(V, [0, 1, 2]) # calculate convolutional layer output x = tf.nn.bias_add(tf.nn.conv2d(x, W, [1] + stride + [1], padding, data_format=data_format), b) return x, g, b
def conv(inp, name, filter_size, out_channels, stride=1, padding='SAME', nonlinearity=None, init_scale=1.0): with tf.variable_scope(name): strides = [1, stride, stride, 1] in_channels = inp.get_shape().as_list()[3] if tf.GLOBAL['init']: V = tf.get_variable( 'V', shape=filter_size + [in_channels, out_channels], dtype=tf.float32, initializer=tf.random_normal_initializer(0, 0.05), trainable=True) V_norm = tf.nn.l2_normalize(V.initialized_value(), [0, 1, 2]) out = tf.nn.conv2d(inp, V_norm, strides, padding) m_init, v_init = tf.nn.moments(out, [0, 1, 2]) scale_init = init_scale / tf.sqrt(v_init + 1e-8) g = tf.get_variable('g', shape=None, dtype=tf.float32, initializer=scale_init, trainable=True) b = tf.get_variable('b', shape=None, dtype=tf.float32, initializer=-m_init * scale_init, trainable=True) out = tf.reshape(scale_init, [1, 1, 1, out_channels]) * ( out - tf.reshape(m_init, [1, 1, 1, out_channels])) if nonlinearity is not None: out = nonlinearity(out) return out else: V, g, b = tf.get_variable('V'), tf.get_variable( 'g'), tf.get_variable('b') tf.assert_variables_initialized([V, g, b]) W = g[None, None, None] * tf.nn.l2_normalize(V, [0, 1, 2]) out = tf.nn.conv2d(inp, W, strides, padding) + b[None, None, None] if nonlinearity is not None: out = nonlinearity(out) return out
def weight_norm_deconv2d(x, output_dim, k_h, k_w, d_h, d_w, init=False, init_scale=1.0, stddev=0.02, name="wn_deconv2d", initializer=tf.truncated_normal_initializer): """Performs Transposed Convolution with Weight Normalization.""" xs = x.get_shape().as_list() target_shape = [xs[0], xs[1] * d_h, xs[2] * d_w, output_dim] with tf.variable_scope(name): if init: v = tf.get_variable( "V", [k_h, k_w] + [output_dim, int(x.get_shape()[-1])], tf.float32, initializer(0, stddev), trainable=True) v_norm = tf.nn.l2_normalize(v.initialized_value(), [0, 1, 3]) x_init = tf.nn.conv2d_transpose(x, v_norm, target_shape, [1, d_h, d_w, 1], padding="SAME") m_init, v_init = tf.nn.moments(x_init, [0, 1, 2]) scale_init = init_scale / tf.sqrt(v_init + 1e-8) g = tf.get_variable("g", dtype=tf.float32, initializer=scale_init, trainable=True) b = tf.get_variable("b", dtype=tf.float32, initializer=-m_init * scale_init, trainable=True) x_init = tf.reshape(scale_init, [1, 1, 1, output_dim]) * ( x_init - tf.reshape(m_init, [1, 1, 1, output_dim])) return x_init else: v = tf.get_variable("v") g = tf.get_variable("g") b = tf.get_variable("b") tf.assert_variables_initialized([v, g, b]) w = tf.reshape(g, [1, 1, output_dim, 1]) * tf.nn.l2_normalize( v, [0, 1, 3]) x = tf.nn.conv2d_transpose(x, w, target_shape, strides=[1, d_h, d_w, 1], padding="SAME") x = tf.nn.bias_add(x, b) return x
def conv(inp, name, filter_size, out_channels, stride=1, padding='SAME', nonlinearity=None, init_scale=1.0, dilation=None): """Convolutional layer. If tf.GLOBAL['init'] is true, this creates the layers paramenters (g, b, W) : L(x) = g|W| (*) x + b Args: x: input tensor name (str): variable scope name filter_size (int pair): filter size out_channels (int): number of output channels strid (int): horizontal and vertical stride padding (str): padding mode nonlinearity (func): activation function init_scale: initial scale for the weights and bias variables dilation: optional dilation rate """ with tf.variable_scope(name): strides = [1, stride, stride, 1] in_channels = inp.get_shape().as_list()[3] if tf.GLOBAL['init']: V = get_variable('V', shape=tuple(filter_size) + (in_channels, out_channels), dtype=tf.float32, initializer=tf.random_normal_initializer(0, 0.05), trainable=True) V_norm = tf.nn.l2_normalize(V.initialized_value(), [0, 1, 2]) if dilation is None: out = tf.nn.conv2d(inp, V_norm, strides, padding) else: assert(stride == 1) out = tf.nn.atrous_conv2d(inp, V_norm, dilation, padding) m_init, v_init = tf.nn.moments(out, [0, 1, 2]) scale_init = init_scale / tf.sqrt(v_init + 1e-8) g = get_variable('g', shape=None, dtype=tf.float32, initializer=scale_init, trainable=True, regularizer=tf.contrib.layers.l2_regularizer(tf.GLOBAL['reg'])) b = get_variable('b', shape=None, dtype=tf.float32, initializer=-m_init * scale_init, trainable=True, regularizer=tf.contrib.layers.l2_regularizer(tf.GLOBAL['reg'])) out = tf.reshape(scale_init, [1, 1, 1, out_channels]) * (out - tf.reshape(m_init, [1, 1, 1, out_channels])) if nonlinearity is not None: out = nonlinearity(out) else: V, g, b = get_variable('V'), get_variable('g'), get_variable('b') tf.assert_variables_initialized([V, g, b]) W = g[None, None, None] * tf.nn.l2_normalize(V, [0, 1, 2]) if dilation is None: out = tf.nn.conv2d(inp, W, strides, padding) + b[None, None, None] else: assert(stride == 1) out = tf.nn.atrous_conv2d(inp, W, dilation, padding) + b[None, None, None] if nonlinearity is not None: out = nonlinearity(out) return out
def fully_connected(x, num_outputs, activation_fn=None, init_scale=1., is_init=False, ema=None, name=None): ''' fully connected layer ''' with tf.variable_scope(name, default_name='Full'): if is_init: # data based initialization of parameters V = tf.get_variable('V', [int(x.get_shape()[1]), num_outputs], tf.float32, tf.random_normal_initializer(0, 0.05), trainable=True) V_norm = tf.nn.l2_normalize(V.initialized_value(), [0]) x_init = tf.matmul(x, V_norm) m_init, v_init = tf.nn.moments(x_init, [0]) scale_init = init_scale / tf.sqrt(v_init + 1e-10) g = tf.get_variable('g', dtype=tf.float32, initializer=scale_init, trainable=True) b = tf.get_variable('b', dtype=tf.float32, initializer=-m_init * scale_init, trainable=True) x_init = scale_init * (x_init - m_init) if activation_fn is not None: x_init = activation_fn(x_init) return x_init else: V = tf.get_variable('V') g = tf.get_variable('g') b = tf.get_variable('b') tf.assert_variables_initialized([V, g, b]) # use weight normalization (Salimans & Kingma, 2016) x = tf.matmul(x, V) scaler = g / tf.sqrt(tf.reduce_sum(tf.square(V), [0])) x = scaler * x + b # apply activation_fn if activation_fn is not None: x = activation_fn(x) return x
def testPrepareSessionFails(self): checkpoint_dir = os.path.join(self.get_temp_dir(), "prepare_session") checkpoint_dir2 = os.path.join(self.get_temp_dir(), "prepare_session2") try: gfile.DeleteRecursively(checkpoint_dir) gfile.DeleteRecursively(checkpoint_dir2) except OSError: pass # Ignore gfile.MakeDirs(checkpoint_dir) with tf.Graph().as_default(): v = tf.Variable([1.0, 2.0, 3.0], name="v") sm = tf.train.SessionManager(ready_op=tf.assert_variables_initialized()) saver = tf.train.Saver({"v": v}) sess = sm.prepare_session( "", init_op=tf.initialize_all_variables(), saver=saver, checkpoint_dir=checkpoint_dir ) self.assertAllClose([1.0, 2.0, 3.0], sess.run(v)) checkpoint_filename = os.path.join(checkpoint_dir, "prepare_session_checkpoint") saver.save(sess, checkpoint_filename) # Create a new Graph and SessionManager and recover. with tf.Graph().as_default(): # Renames the checkpoint directory. os.rename(checkpoint_dir, checkpoint_dir2) gfile.MakeDirs(checkpoint_dir) v = tf.Variable([6.0, 7.0, 8.0], name="v") with self.test_session(): self.assertEqual(False, tf.is_variable_initialized(v).eval()) tf.train.SessionManager(ready_op=tf.assert_variables_initialized()) saver = tf.train.Saver({"v": v}) # This should fail as there's no checkpoint within 2 seconds. with self.assertRaisesRegexp(RuntimeError, "no init_op or init_fn was given"): sess = sm.prepare_session( "", init_op=None, saver=saver, checkpoint_dir=checkpoint_dir, wait_for_checkpoint=True, max_wait_secs=2, ) # Rename the checkpoint directory back. gfile.DeleteRecursively(checkpoint_dir) os.rename(checkpoint_dir2, checkpoint_dir) # This should succeed as there's checkpoint. sess = sm.prepare_session( "", init_op=None, saver=saver, checkpoint_dir=checkpoint_dir, wait_for_checkpoint=True, max_wait_secs=2 ) self.assertEqual(True, tf.is_variable_initialized(sess.graph.get_tensor_by_name("v:0")).eval(session=sess))
def __init__(self, model, conf, model_path=None): self.model = model self.conf = conf print('Defining the session') sess_config = tf.ConfigProto() sess_config.allow_soft_placement = True sess_config.gpu_options.allow_growth = True self.sess = tf.Session(config=sess_config) self.sess.run(tf.global_variables_initializer()) try: self.sess.run(tf.assert_variables_initialized()) except tf.errors.FailedPreconditionError: raise RuntimeError('Not all variables initialized') self.saver = tf.train.Saver(tf.global_variables()) if model_path: print('Restoring model from: ' + str(model_path)) self.saver.restore(self.sess, model_path) self.binary_opening_filter = sitk.BinaryMorphologicalOpeningImageFilter( ) self.binary_opening_filter.SetKernelRadius(1) self.binary_closing_filter = sitk.BinaryMorphologicalClosingImageFilter( ) self.binary_closing_filter.SetKernelRadius(1) self.erosion_filter = sitk.BinaryErodeImageFilter() self.erosion_filter.SetKernelRadius(1) self.dilation_filter = sitk.BinaryDilateImageFilter() self.dilation_filter.SetKernelRadius(1)
def initialize(self, *args, **kwargs): super().initialize() # invalidate saver self._saver = None self.guidance = kwargs.get('guidance') self.summary_service = kwargs.get('summary_service') self.log_directory = kwargs.get('log_directory', '.') self.checkpoints_directory = kwargs.get('checkpoints_directory', '.') self.evaluations_directory = kwargs.get('evaluations_directory', '.') # ------- init some internal variable ---------- self.training_steps = 0 # training step counter # saves for the current episode an intermediate buffer, which also allows to use an n-step return, save self.episode_buffer = [] tf.reset_default_graph() with self.context.graph.as_default(): # Create variables self.create_variables() # merge all summaries self.summarize = tf.summary.merge_all() self.no_op = tf.no_op() var_lists = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES) # initialize variables self.context.session.run(tf.variables_initializer(var_lists)) # Make sure all variables are initialized self.context.session.run(tf.assert_variables_initialized()) # initialize common summaries for all agents self._initialize_summary_writer()
def testPrepareSessionSucceedsWithInitFn(self): with tf.Graph().as_default(): v = tf.Variable([125], name="v") sm = tf.train.SessionManager(ready_op=tf.assert_variables_initialized()) sess = sm.prepare_session("", init_fn=lambda sess: sess.run(v.initializer)) self.assertAllClose([125], sess.run(v))
def init_variables(self): check_vars_initialized = tf.assert_variables_initialized( self.variables) try: self.session.run(check_vars_initialized) except tf.errors.FailedPreconditionError: self.session.run(tf.variables_initializer(self.variables))
def conv2d(x, num_filters, filter_size=[3, 3], stride=[1, 1], pad='SAME', init_scale=1., counters={}, init=False, **kwargs): ''' convolutional layer ''' num_filters = int(num_filters) strides = [1] + stride + [1] name = get_name('conv2d', counters) with tf.variable_scope(name): if init: xs = x.shape.as_list() # data based initialization of parameters V = tf.get_variable('V', filter_size + [xs[-1], num_filters], tf.float32, tf.random_normal_initializer(0, 0.05)) V_norm = tf.nn.l2_normalize(V.initialized_value(), [0, 1, 2]) x_init = tf.nn.conv2d(x, V_norm, strides, pad) m_init, v_init = tf.nn.moments(x_init, [0, 1, 2]) scale_init = init_scale / tf.sqrt(v_init + 1e-8) g = tf.get_variable('g', dtype=tf.float32, initializer = scale_init) b = tf.get_variable('b', dtype=tf.float32, initializer = -m_init * scale_init) x_init = tf.reshape(scale_init, [1, 1, 1, num_filters]) * (x_init - tf.reshape(m_init, [1, 1, 1, num_filters])) return x_init else: V = tf.get_variable("V") g = tf.get_variable("g") b = tf.get_variable("b") with tf.control_dependencies([tf.assert_variables_initialized([V, g, b])]): # use weight normalization (Salimans & Kingma, 2016) W = tf.reshape(g, [1, 1, 1, num_filters]) * tf.nn.l2_normalize(V, [0, 1, 2]) # calculate convolutional layer output x = tf.nn.bias_add(tf.nn.conv2d(x, W, strides, pad), b) return x
def testPrepareSessionSucceedsWithInitFeedDict(self): with tf.Graph().as_default(): p = tf.placeholder(tf.float32, shape=(3,)) v = tf.Variable(p, name="v") sm = tf.train.SessionManager(ready_op=tf.assert_variables_initialized()) sess = sm.prepare_session("", init_op=tf.initialize_all_variables(), init_feed_dict={p: [1.0, 2.0, 3.0]}) self.assertAllClose([1.0, 2.0, 3.0], sess.run(v))
def __init__(self, session, optimizer, q_network, state_dim, num_actions, batch_size=32, init_exp=0.5, final_exp=0.1, anneal_steps=10000, replay_buffer_size=10000, store_replay_every=5, discount_factor=0.9, target_update_rate=0.01, reg_param=0.01, max_gradient=5, double_q_learning=False, summary_writer=None, summary_every=100): self.summary_every=1 # tensorflow self.session=session self.optimizer=optimizer self.summary_writer=summary_writer # model parts self.q_network=q_network self.replayBuffer=ReplayBuffer(buffer_size=replay_buffer_size) # q learning self.batch_size = batch_size self.state_dim = state_dim self.num_actions = num_actions self.exploration = init_exp self.final_exp = final_exp self.anneal_steps = anneal_steps self.discount_factor = discount_factor self.target_update_rate = target_update_rate self.double_q_learning = double_q_learning # training self.max_gradient = max_gradient self.reg_param = reg_param # counter self.store_replay_every = store_replay_every self.store_experience_cost = 0 self.train_iteration = reg_param #initialize self.create_variables() var_lists = tf.get_collection(tf.GraphKeys.VARIABLES) self.session.run(tf.initialize_vatriables(var_lists)) # verify self.session.run(tf.assert_variables_initialized()) if self.summary_writer is not None: self.summary_writer.add_graph(self.session.graph) self.summary_every = summary_every
def __init__(self, state_size, num_steps, num_classes, learning_rate, summary_every=100): """Create a Basic RNN classfier with the given STATE_SIZE, NUM_STEPS, and NUM_CLASSES """ self.state_size = state_size self.num_steps = num_steps self.num_classes = num_classes self.learning_rate = learning_rate # tensorflow machinery self.session = tf.Session() self.summary_writer = tf.summary.FileWriter( os.path.join(os.getcwd(), "tensorboard/")) self.no_op = tf.no_op() # counters self.train_itr = 0 # create and initialize variables self.create_graph() var_lists = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES) self.session.run(tf.variables_initializer(var_lists)) # make sure all variables are initialized self.session.run(tf.assert_variables_initialized()) # add the graph self.summary_writer.add_graph(self.session.graph) self.summary_every = summary_every
def __init__( self, session, optimizer, q_network, state_dim, num_actions, batch_size=32, # batch size init_exp=0.5, # initial exploration prob final_exp=0.1, # final exploration prob anneal_steps=10000, # number of steps for annealing exploration replay_buffer_size=10000, store_replay_every=5, # how frequent to store experience discount_factor=0.9, # discount future rewards target_update_rate=0.01, reg_param=0.01, # regularization constants max_gradient=5, # max gradient norms double_q_learning=False, summary_writer=None, summary_every=100): # tensorflow setup self.session = session self.optimizer = optimizer self.summary_writer = summary_writer # model components self.q_network = q_network self.replay_buffer = ReplayBuffer(buffer_size=replay_buffer_size) # Q-learning parameters self.batch_size = batch_size self.state_dim = state_dim self.num_actions = num_actions self.exploration = init_exp self.init_exp = init_exp self.final_exp = final_exp self.anneal_steps = anneal_steps self.discount_factor = discount_factor self.target_update_rate = target_update_rate self.double_q_learning = double_q_learning # training parameters self.max_gradient = max_gradient self.reg_param = reg_param # counters self.store_replay_every = store_replay_every self.store_experience_cnt = 0 self.train_iteration = 0 # create and initializer variables self.create_variables() var_lists = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES) self.session.run(tf.variables_initializer(var_lists)) # assert that all variables are initialized self.session.run(tf.assert_variables_initialized()) if self.summary_writer is not None: self.summary_writer.add_graph(self.session.graph) self.summary_every = summary_every
def dense(x, num_units, init_scale=1., counters={}, init=False, **kwargs): ''' fully connected layer ''' name = get_name('dense', counters) with tf.variable_scope(name): if init: xs = x.shape.as_list() # data based initialization of parameters V = tf.get_variable('V', [xs[1], num_units], tf.float32, tf.random_normal_initializer(0, 0.05)) V_norm = tf.nn.l2_normalize(V.initialized_value(), [0]) x_init = tf.matmul(x, V_norm) m_init, v_init = tf.nn.moments(x_init, [0]) scale_init = init_scale / tf.sqrt(v_init + 1e-10) g = tf.get_variable('g', dtype=tf.float32, initializer=scale_init) b = tf.get_variable('b', dtype=tf.float32, initializer=-m_init * scale_init) x_init = tf.reshape(scale_init, [1, num_units]) * ( x_init - tf.reshape(m_init, [1, num_units])) return x_init else: V = tf.get_variable("V") g = tf.get_variable("g") b = tf.get_variable("b") with tf.control_dependencies( [tf.assert_variables_initialized([V, g, b])]): # use weight normalization (Salimans & Kingma, 2016) x = tf.matmul(x, V) scaler = g / tf.sqrt(tf.reduce_sum(tf.square(V), [0])) x = tf.reshape(scaler, [1, num_units]) * x + tf.reshape( b, [1, num_units]) return x
def testPrepareSessionSucceedsWithInitFn(self): with tf.Graph().as_default(): v = tf.Variable([125], name="v") sm = tf.train.SessionManager(ready_op=tf.assert_variables_initialized()) sess = sm.prepare_session("", init_fn=lambda sess: sess.run(v.initializer)) self.assertAllClose([125], sess.run(v))
def __init__(self, session, optimizer_critic, optimizer_actor, critic_network, actor_network, gamma_lmbda, state_dim, num_actions, summary_writer=None, summary_every=5): self.session = session self.summary_writer = summary_writer self.optimizer_critic = optimizer_critic self.optimizer_actor = optimizer_actor self.actor_network = actor_network self.critic_network = critic_network self.state_dim = state_dim self.num_actions = num_actions self.gamma_lmbda = tf.constant(gamma_lmbda) # initialize the graph on tensorflow self.create_variables() var_lists = tf.get_collection(tf.GraphKeys.VARIABLES) self.session.run(tf.initialize_variables(var_lists)) # make sure the variables in graph are initialized self.session.run(tf.assert_variables_initialized()) if self.summary_writer is not None: self.summary_writer.add_graph(self.session.graph) self.summary_every = summary_every
def deconv2d(x, num_filters, filter_size=[3, 3], stride=[1, 1], pad='SAME', nonlinearity=None, init_scale=1., counters={}, init=False, ema=None, **kwargs): ''' transposed convolutional layer ''' name = get_name('deconv2d', counters) xs = int_shape(x) if pad == 'SAME': target_shape = [xs[0], xs[1] * stride[0], xs[2] * stride[1], num_filters] else: target_shape = [xs[0], xs[1] * stride[0] + filter_size[0] - 1, xs[2] * stride[1] + filter_size[1] - 1, num_filters] with tf.variable_scope(name): if init: # data based initialization of parameters V = tf.get_variable('V', filter_size + [num_filters, int(x.get_shape( )[-1])], tf.float32, tf.random_normal_initializer(0, 0.05), trainable=True) V_norm = tf.nn.l2_normalize(V.initialized_value(), [0, 1, 3]) x_init = tf.nn.conv2d_transpose(x, V_norm, target_shape, [ 1] + stride + [1], padding=pad) m_init, v_init = tf.nn.moments(x_init, [0, 1, 2]) scale_init = init_scale / tf.sqrt(v_init + 1e-8) g = tf.get_variable('g', dtype=tf.float32, initializer=scale_init, trainable=True) b = tf.get_variable('b', dtype=tf.float32, initializer=-m_init * scale_init, trainable=True) x_init = tf.reshape(scale_init, [ 1, 1, 1, num_filters]) * (x_init - tf.reshape(m_init, [1, 1, 1, num_filters])) if nonlinearity is not None: x_init = nonlinearity(x_init) return x_init else: V, g, b = get_vars_maybe_avg(['V', 'g', 'b'], ema) tf.assert_variables_initialized([V, g, b]) # use weight normalization (Salimans & Kingma, 2016) W = tf.reshape(g, [1, 1, num_filters, 1]) * \ tf.nn.l2_normalize(V, [0, 1, 3]) # calculate convolutional layer output x = tf.nn.conv2d_transpose( x, W, target_shape, [1] + stride + [1], padding=pad) x = tf.nn.bias_add(x, b) # apply nonlinearity if nonlinearity is not None: x = nonlinearity(x) return x
def __init__( self, session, optimizer, policy_network, state_dim, num_actions, gru_unit_size, num_step, num_layers, save_path, global_step, max_gradient=5, # max gradient norms entropy_bonus=0.001, summary_writer=None, summary_every=100, loss_function="l2"): # tensorflow machinery self.session = session self.optimizer = optimizer self.summary_writer = summary_writer self.summary_every = summary_every self.gru_unit_size = gru_unit_size self.num_step = num_step self.num_layers = num_layers self.no_op = tf.no_op() # model components self.policy_network = policy_network self.state_dim = state_dim self.num_actions = num_actions self.loss_function = loss_function # training parameters self.max_gradient = max_gradient self.entropy_bonus = entropy_bonus #counter self.global_step = global_step self.reward_stats = [] # create and initialize variables self.create_variables() var_lists = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES) self.session.run(tf.variables_initializer(var_lists)) # make sure all variables are initialized self.session.run(tf.assert_variables_initialized()) # try load saved model self.saver = tf.train.Saver(tf.global_variables()) self.save_path = save_path self.load_model() if self.summary_writer is not None: # graph was not available when journalist was created self.summary_writer.add_graph(self.session.graph) self.summary_every = summary_every
def __init__(self, session, optimizer, policy_network, state_dim, num_actions, init_exp=0.1, # initial exploration prob final_exp=0.0, # final exploration prob anneal_steps=10000, # N steps for annealing exploration discount_factor=0.99, # discount future rewards reg_param=0.0001, # regularization constants max_gradient=5, # max gradient norms summary_writer=None, summary_every=100): # tensorflow machinery self.session = session self.optimizer = optimizer self.summary_writer = summary_writer # model components self.policy_network = policy_network # training parameters self.state_dim = state_dim self.num_actions = num_actions self.discount_factor = discount_factor self.max_gradient = max_gradient self.reg_param = reg_param # exploration parameters self.exploration = init_exp self.init_exp = init_exp self.final_exp = final_exp self.anneal_steps = anneal_steps # counters self.train_iteration = 0 # rollout buffer self.state_buffer = [] self.reward_buffer = [] self.action_buffer = [] # record reward history for normalization self.all_rewards = [] self.max_reward_length = 10000 # create and initialize variables self.create_variables() var_lists = tf.get_collection(tf.GraphKeys.VARIABLES) self.session.run(tf.initialize_variables(var_lists)) # make sure all variables are initialized self.session.run(tf.assert_variables_initialized()) if self.summary_writer is not None: # graph was not available when journalist was created self.summary_writer.add_graph(self.session.graph_def) self.summary_every = summary_every
def __init__(self, session, optimizer, policy_network, state_dim, num_actions, init_exp=0.5, # initial exploration prob final_exp=0.0, # final exploration prob anneal_steps=10000, # N steps for annealing exploration discount_factor=0.99, # discount future rewards reg_param=0.001, # regularization constants max_gradient=5, # max gradient norms summary_writer=None, summary_every=100): # tensorflow machinery self.session = session self.optimizer = optimizer self.summary_writer = summary_writer # model components self.policy_network = policy_network # training parameters self.state_dim = state_dim self.num_actions = num_actions self.discount_factor = discount_factor self.max_gradient = max_gradient self.reg_param = reg_param # exploration parameters self.exploration = init_exp self.init_exp = init_exp self.final_exp = final_exp self.anneal_steps = anneal_steps # counters self.train_iteration = 0 # rollout buffer self.state_buffer = [] self.reward_buffer = [] self.action_buffer = [] # record reward history for normalization self.all_rewards = [] self.max_reward_length = 1000000 # create and initialize variables self.create_variables() var_lists = tf.get_collection(tf.GraphKeys.VARIABLES) self.session.run(tf.initialize_variables(var_lists)) # make sure all variables are initialized self.session.run(tf.assert_variables_initialized()) if self.summary_writer is not None: # graph was not available when journalist was created self.summary_writer.add_graph(self.session.graph) self.summary_every = summary_every
def __init__(self, session, optimizer, actor_network, critic_network, state_dim, action_dim, batch_size=32, replay_buffer_size=1000000, # size of replay buffer store_replay_every=1, # how frequent to store experience discount_factor=0.99, # discount future rewards target_update_rate=0.01, reg_param=0.01, # regularization constants max_gradient=5, # max gradient norms noise_sigma=0.20, noise_theta=0.15, summary_writer=None, summary_every=100): # tensorflow machinery self.session = session self.optimizer = optimizer self.summary_writer = summary_writer # model components self.actor_network = actor_network self.critic_network = critic_network self.replay_buffer = ReplayBuffer(buffer_size=replay_buffer_size) # training parameters self.batch_size = batch_size self.state_dim = state_dim self.action_dim = action_dim self.discount_factor = discount_factor self.target_update_rate = target_update_rate self.max_gradient = max_gradient self.reg_param = reg_param # Ornstein-Uhlenbeck noise for exploration self.noise_var = tf.Variable(tf.zeros([1, action_dim])) noise_random = tf.random_normal([1, action_dim], stddev=noise_sigma) self.noise = self.noise_var.assign_sub((noise_theta) * self.noise_var - noise_random) # counters self.store_replay_every = store_replay_every self.store_experience_cnt = 0 self.train_iteration = 0 # create and initialize variables self.create_variables() var_lists = tf.get_collection(tf.GraphKeys.VARIABLES) self.session.run(tf.initialize_variables(var_lists)) # make sure all variables are initialized self.session.run(tf.assert_variables_initialized()) if self.summary_writer is not None: # graph was not available when journalist was created self.summary_writer.add_graph(self.session.graph) self.summary_every = summary_every
def __init__(self, session, optimizer, actor_network, critic_network, state_dim, action_dim, batch_size=32, replay_buffer_size=1000000, # size of replay buffer store_replay_every=1, # how frequent to store experience discount_factor=0.99, # discount future rewards target_update_rate=0.01, reg_param=0.01, # regularization constants max_gradient=5, # max gradient norms noise_sigma=0.20, noise_theta=0.15, summary_writer=None, summary_every=100): # tensorflow machinery self.session = session self.optimizer = optimizer self.summary_writer = summary_writer # model components self.actor_network = actor_network self.critic_network = critic_network self.replay_buffer = ReplayBuffer(buffer_size=replay_buffer_size) # training parameters self.batch_size = batch_size self.state_dim = state_dim self.action_dim = action_dim self.discount_factor = discount_factor self.target_update_rate = target_update_rate self.max_gradient = max_gradient self.reg_param = reg_param # Ornstein-Uhlenbeck noise for exploration self.noise_var = tf.Variable(tf.zeros([1, action_dim])) noise_random = tf.random_normal([1, action_dim], stddev=noise_sigma) self.noise = self.noise_var.assign_sub((noise_theta) * self.noise_var - noise_random) # counters self.store_replay_every = store_replay_every self.store_experience_cnt = 0 self.train_iteration = 0 # create and initialize variables self.create_variables() var_lists = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES) self.session.run(tf.variables_initializer(var_lists)) # make sure all variables are initialized self.session.run(tf.assert_variables_initialized()) if self.summary_writer is not None: # graph was not available when journalist was created self.summary_writer.add_graph(self.session.graph) self.summary_every = summary_every
def testWaitForSessionReturnsNoneAfterTimeout(self): with tf.Graph().as_default(): tf.Variable(1, name="v") sm = tf.train.SessionManager(ready_op=tf.assert_variables_initialized(), recovery_wait_secs=1) # Set max_wait_secs to allow us to try a few times. with self.assertRaises(errors.DeadlineExceededError): sm.wait_for_session(master="", max_wait_secs=3)
def initializeRemainingVars(sess, feed_dict): varlist = tf.global_variables() for var in varlist: try: sess.run(tf.assert_variables_initialized([var])) except tf.errors.FailedPreconditionError: sess.run(tf.variables_initializer([var])) print('Initializing variable:%s' % var.name)
def initializeRemainingVars(sess,feed_dict): varlist = tf.global_variables() for var in varlist: try: sess.run(tf.assert_variables_initialized([var])) except tf.errors.FailedPreconditionError: sess.run(tf.variables_initializer([var])) print('Initializing variable:%s'%var.name)
def testPrepareSessionSucceeds(self): with tf.Graph().as_default(): v = tf.Variable([1.0, 2.0, 3.0], name="v") sm = tf.train.SessionManager( ready_op=tf.assert_variables_initialized()) sess = sm.prepare_session("", init_op=tf.initialize_all_variables()) self.assertAllClose([1.0, 2.0, 3.0], sess.run(v))
def testPrepareSessionSucceedsWithInitFeedDict(self): with tf.Graph().as_default(): p = tf.placeholder(tf.float32, shape=(3,)) v = tf.Variable(p, name="v") sm = tf.train.SessionManager(ready_op=tf.assert_variables_initialized()) sess = sm.prepare_session("", init_op=tf.initialize_all_variables(), init_feed_dict={p: [1.0, 2.0, 3.0]}) self.assertAllClose([1.0, 2.0, 3.0], sess.run(v))
def testWaitForSessionReturnsNoneAfterTimeout(self): with tf.Graph().as_default(): tf.Variable(1, name="v") sm = tf.train.SessionManager(ready_op=tf.assert_variables_initialized(), recovery_wait_secs=1) # Set max_wait_secs to allow us to try a few times. with self.assertRaises(errors.DeadlineExceededError): sm.wait_for_session(master="", max_wait_secs=3000)
def _create_initializers(self): if self._var_count != len(tf.all_variables()): self._saver = tf.train.Saver(tf.all_variables(), max_to_keep=5) self._init = tf.initialize_all_variables() self._check_inited = tf.assert_variables_initialized() self._var_count = len(tf.all_variables()) if self._summary_writer: self._summaries = tf.merge_all_summaries() self._summary_writer.add_graph(tf.get_default_graph().as_graph_def())
def start(self): with self._sess.graph.as_default(): self.run(tf.assert_variables_initialized()) # create and launch threads for all queue_runners # it is like start_queue_runners, but manually for qr in tf.get_collection(tf.GraphKeys.QUEUE_RUNNERS): self._threads.extend(qr.create_threads( self._sess, coord=self._coord, daemon=True, start=True ))
def __init__(self, session, optimizer, policy_network, observation_dim, num_actions, gru_unit_size, num_step, num_layers, save_path, global_step, max_gradient=5, entropy_bonus=0.001, summary_writer=None, loss_function="l2", summary_every=100): # tensorflow machinery self.session = session self.optimizer = optimizer self.summary_writer = summary_writer self.summary_every = summary_every self.gru_unit_size = gru_unit_size self.num_step = num_step self.num_layers = num_layers self.no_op = tf.no_op() # model components self.policy_network = policy_network self.observation_dim = observation_dim self.num_actions = num_actions self.loss_function = loss_function # training parameters self.max_gradient = max_gradient self.entropy_bonus = entropy_bonus #counter self.global_step = global_step # create and initialize variables self.create_variables() var_lists = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES) self.session.run(tf.variables_initializer(var_lists)) # make sure all variables are initialized self.session.run(tf.assert_variables_initialized()) # try load saved model self.saver = tf.train.Saver(tf.global_variables()) self.save_path = save_path self.load_model() if self.summary_writer is not None: # graph was not available when journalist was created self.summary_writer.add_graph(self.session.graph) self.summary_every = summary_every
def __init__( self, optimizer, session, Network, env:gym.Env, learning_rate: int , in_dim : int, out_dim : int, memory_size: int, batch_size: int, target_update: int, epsilon_decay: float, max_epsilon: float = 1.0, min_epsilon: float = 0.1, gamma: float = 0.99): obs_dim = env.observation_space.shape[0] action_dim = env.action_space.n self.env = env self.learning_rate = learning_rate self.memory = Replay_Buffer(obs_dim, memory_size, batch_size) self.batch_size = batch_size self.epsilon = max_epsilon self.epsilon_decay = epsilon_decay self.max_epsilon = max_epsilon self.min_epsilon = min_epsilon self.target_update = target_update self.gamma = gamma self.in_dim = in_dim self.out_dim = out_dim self.target_params = None self.mask = None self.doulbe_mask = None self.target_Q_Value = None self.estimated_Q_Value = None self.loss = None self.train_op = None self.sess = session self.optimizer = optimizer with tf.variable_scope("model", reuse=tf.AUTO_REUSE): self.dqn = Network self.states = tf.placeholder(tf.float32, shape = [None, self.in_dim], name="states") self.estimated_Q_Value = self.dqn(self.states) self.mask = tf.placeholder(tf.float32, shape = [None, 2], name="mask") self.replay_estimated_Q_Value = tf.multiply(self.dqn(self.states), self.mask) self.replay_estimated_Q_Value = tf.reduce_max(self.replay_estimated_Q_Value, axis=1) with tf.variable_scope("target", reuse=False): self.dqn_target = Network self.target_states = tf.placeholder(tf.float32, shape = [None, self.in_dim], name="next_states") self.doulbe_mask = tf.placeholder(tf.float32, shape = [None, 2], name="double_mask") self.reward = tf.placeholder(tf.float32, shape = [None, ], name="reward") self.target_Q_Value = tf.reduce_max( self.gamma * tf.multiply(self.dqn_target(self.target_states), self.doulbe_mask),axis = 1) + self.reward self.target_Q_Value = tf.stop_gradient(self.target_Q_Value) self.loss = pow(self.target_Q_Value - self.replay_estimated_Q_Value,2)/2 self.train_op = self.optimizer.minimize(self.loss) var_lists = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES) self.sess.run(tf.variables_initializer(var_lists)) self.sess.run(tf.assert_variables_initialized()) self.transition = list() self.is_test = False
def testVariables(self): with tf.Graph().as_default(), self.test_session() as sess: v = tf.Variable([1, 2]) w = tf.Variable([3, 4]) _ = v, w inited = tf.assert_variables_initialized() with self.assertRaisesOpError("Attempting to use uninitialized value"): sess.run(inited) tf.initialize_all_variables().run() sess.run(inited)
def _create_initializers(self): if self._var_count != len(tf.all_variables()): save_dir = os.path.dirname(self._save_path) if self._save_path else None if save_dir and not tf.gfile.IsDirectory(save_dir): tf.gfile.MakeDirs(save_dir) self._saver = tf.train.Saver(tf.all_variables(), max_to_keep=5) self._init = tf.initialize_all_variables() self._check_inited = tf.assert_variables_initialized() self._var_count = len(tf.all_variables()) if self._summary_writer: self._summaries = tf.merge_all_summaries() self._summary_writer.add_graph(tf.get_default_graph())
def testVariableList(self): with tf.Graph().as_default(), self.test_session() as sess: v = tf.Variable([1, 2]) w = tf.Variable([3, 4]) inited = tf.assert_variables_initialized([v]) with self.assertRaisesOpError("Attempting to use uninitialized value"): inited.op.run() sess.run(w.initializer) with self.assertRaisesOpError("Attempting to use uninitialized value"): inited.op.run() v.initializer.run() inited.op.run()
def is_initialized_in(self, session): """Check if the TensorFlow variables are initialized""" if self._initialized: return True tf_var_list = self.get_tensorflow_variables() if len(tf_var_list) == 0: return True try: session.run(tf.assert_variables_initialized(self.get_tensorflow_variables())) self._initialized = True return True except tf.errors.FailedPreconditionError: return False
def dense(x, num_units, nonlinearity=None, init_scale=1., counters={}, init=False, ema=None, **kwargs): ''' fully connected layer ''' name = get_name('dense', counters) with tf.variable_scope(name): if init: # data based initialization of parameters V = tf.get_variable('V', [int(x.get_shape()[ 1]), num_units], tf.float32, tf.random_normal_initializer(0, 0.05), trainable=True) V_norm = tf.nn.l2_normalize(V.initialized_value(), [0]) x_init = tf.matmul(x, V_norm) m_init, v_init = tf.nn.moments(x_init, [0]) scale_init = init_scale / tf.sqrt(v_init + 1e-10) g = tf.get_variable('g', dtype=tf.float32, initializer=scale_init, trainable=True) b = tf.get_variable('b', dtype=tf.float32, initializer=-m_init * scale_init, trainable=True) x_init = tf.reshape( scale_init, [1, num_units]) * (x_init - tf.reshape(m_init, [1, num_units])) if nonlinearity is not None: x_init = nonlinearity(x_init) return x_init else: V, g, b = get_vars_maybe_avg(['V', 'g', 'b'], ema) tf.assert_variables_initialized([V, g, b]) # use weight normalization (Salimans & Kingma, 2016) x = tf.matmul(x, V) scaler = g / tf.sqrt(tf.reduce_sum(tf.square(V), [0])) x = tf.reshape(scaler, [1, num_units]) * \ x + tf.reshape(b, [1, num_units]) # apply nonlinearity if nonlinearity is not None: x = nonlinearity(x) return x
def __init__(self, session, optimizer, q_network, state_dim, num_actions, batch_size=32, init_exp=0.5, # initial exploration prob final_exp=0.1, # final exploration prob anneal_steps=10000, # N steps for annealing exploration replay_buffer_size=10000, store_replay_every=5, # how frequent to store experience discount_factor=0.9, # discount future rewards target_update_rate=0.01, reg_param=0.01, # regularization constants max_gradient=5, # max gradient norms double_q_learning=False, summary_writer=None, summary_every=100): # tensorflow machinery self.session = session self.optimizer = optimizer self.summary_writer = summary_writer # model components self.q_network = q_network self.replay_buffer = ReplayBuffer(buffer_size=replay_buffer_size) # Q learning parameters self.batch_size = batch_size self.state_dim = state_dim self.num_actions = num_actions self.exploration = init_exp self.init_exp = init_exp self.final_exp = final_exp self.anneal_steps = anneal_steps self.discount_factor = discount_factor self.target_update_rate = target_update_rate self.double_q_learning = double_q_learning # training parameters self.max_gradient = max_gradient self.reg_param = reg_param # counters self.store_replay_every = store_replay_every self.store_experience_cnt = 0 self.train_iteration = 0 # create and initialize variables self.create_variables() var_lists = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES) self.session.run(tf.variables_initializer(var_lists)) # make sure all variables are initialized self.session.run(tf.assert_variables_initialized()) if self.summary_writer is not None: # graph was not available when journalist was created self.summary_writer.add_graph(self.session.graph) self.summary_every = summary_every
def testNoVars(self): with tf.Graph().as_default(): self.assertEqual(None, tf.assert_variables_initialized())
def trainFine(conf,jointTrain=False,resume=True): # Parameters learning_rate = conf.fine_learning_rate; batch_size = conf.fine_batch_size; display_step = conf.display_step n_input = conf.psz; n_classes = conf.n_classes; dropout = conf.dropout imsz = conf.imsz; rescale = conf.rescale; scale = conf.scale pool_scale = conf.pool_scale x0,x1,x2,y,keep_prob = createPlaceHolders(imsz,rescale,scale,pool_scale,n_classes) locs_ph = tf.placeholder(tf.float32,[conf.batch_size,n_classes,2]) learning_rate_ph = tf.placeholder(tf.float32,shape=[]) weights = initNetConvWeights(conf) pred_gradient,layers = net_multi_conv(x0,x1,x2, weights, keep_prob, imsz,rescale,pool_scale) baseoutname = '%s_%d.ckpt'%(conf.outname,conf.base_training_iters) basemodelfile = os.path.join(conf.cachedir,baseoutname) sess = tf.Session() saver = tf.train.Saver() pred = tf.stop_gradient(pred_gradient) training_iters = conf.fine_training_iters outname = conf.fineoutname print("Restoring base model from:" + basemodelfile) saver.restore(sess, basemodelfile) # Construct fine model labelT = multiPawTools.createFineLabelTensor(conf) layer1_1 = tf.stop_gradient(layers['base_dict_0']['conv1']) layer1_2 = tf.stop_gradient(layers['base_dict_0']['conv2']) layer2_1 = tf.stop_gradient(layers['base_dict_1']['conv1']) layer2_2 = tf.stop_gradient(layers['base_dict_1']['conv2']) curfine1_1 = extractPatches(layer1_1,pred,conf,1,4) curfine1_2 = extractPatches(layer1_2,pred,conf,2,2) curfine2_1 = extractPatches(layer2_1,pred,conf,2,2) curfine2_2 = extractPatches(layer2_2,pred,conf,4,1) curfine1_1u = tf.unpack(tf.transpose(curfine1_1,[1,0,2,3,4])) curfine1_2u = tf.unpack(tf.transpose(curfine1_2,[1,0,2,3,4])) curfine2_1u = tf.unpack(tf.transpose(curfine2_1,[1,0,2,3,4])) curfine2_2u = tf.unpack(tf.transpose(curfine2_2,[1,0,2,3,4])) finepred = fineOut(curfine1_1u,curfine1_2u,curfine2_1u,curfine2_2u,conf) limgs = multiPawTools.createFineLabelImages(locs_ph,pred,conf,labelT) # training data stuff lmdbfilename =os.path.join(conf.cachedir,conf.trainfilename) vallmdbfilename =os.path.join(conf.cachedir,conf.valfilename) env = lmdb.open(lmdbfilename, readonly = True) valenv = lmdb.open(vallmdbfilename, readonly = True) # Define loss and optimizer costFine = tf.reduce_mean(tf.nn.l2_loss(finepred- tf.to_float(limgs))) costBase = tf.reduce_mean(tf.nn.l2_loss(pred- y)) cost = costFine saver1 = tf.train.Saver(max_to_keep=conf.maxckpt) optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate_ph).minimize(cost) outfilename = os.path.join(conf.cachedir,conf.fineoutname) traindatafilename = os.path.join(conf.cachedir,conf.datafinename) latest_ckpt = tf.train.get_checkpoint_state(conf.cachedir, latest_filename = conf.ckptfinename) if not latest_ckpt or not resume: startat = 0 trainData = {'train_err':[],'val_err':[],'step_no':[]} varlist = tf.all_variables() for var in varlist: try: sess.run(tf.assert_variables_initialized([var])) except tf.errors.FailedPreconditionError: sess.run(tf.initialize_variables([var])) else: saver1.restore(latest_ckpt.model_checkpoint_path) matchObj = re.match(outfilename + '-(\d*)',ckpt.model_checkpoint_path) startat = int(matchObj.group(1)+1) tdfile = open(traindatafilename,'rb') trainData = pickle.load(tdfile) tdfile.close() # print('Initializing variable %s'%var.name) # init = tf.initialize_all_variables() # sess.run(init) with env.begin() as txn,valenv.begin() as valtxn: train_cursor = txn.cursor(); val_cursor = valtxn.cursor() # Keep training until reach max iterations for step in range(startat,training_iters): excount = step*batch_size cur_lr = learning_rate * conf.gamma**math.floor(old_div(excount,conf.step_size)) batch_xs, locs = multiPawTools.readLMDB(train_cursor, batch_size,imsz,multiResData) locs = multiResData.sanitize_locs(locs) x0_in,x1_in,x2_in = multiPawTools.iScaleImages( batch_xs.transpose([0,2,3,1]),rescale,scale) labelims = multiPawTools.createLabelImages(locs, conf.imsz,conf.pool_scale*conf.rescale, conf.label_blur_rad) feed_dict={x0: x0_in,x1: x1_in,x2: x2_in, y: labelims, keep_prob: dropout,locs_ph:np.array(locs), learning_rate_ph:cur_lr} sess.run(optimizer, feed_dict = feed_dict) if step % display_step == 0: feed_dict={x0: x0_in,x1: x1_in,x2: x2_in, y: labelims, keep_prob: 1.,locs_ph:np.array(locs)} train_loss = sess.run([cost,costBase], feed_dict=feed_dict) numrep = int(old_div(conf.numTest,conf.batch_size))+1 acc = 0; loss = 0 for rep in range(numrep): val_xs, locs = multiPawTools.readLMDB(val_cursor, batch_size,imsz,multiResData) x0_in,x1_in,x2_in = multiPawTools.multiScaleImages( val_xs.transpose([0,2,3,1]),rescale,scale) labelims = multiPawTools.createLabelImages(locs, conf.imsz,conf.pool_scale*conf.rescale, conf.label_blur_rad) feed_dict={x0: x0_in,x1: x1_in,x2: x2_in, y: labelims, keep_prob:1.,locs_ph:np.array(locs)} loss += sess.run(cost, feed_dict=feed_dict) loss = old_div((old_div(loss,numrep)),batch_size) print("Iter " + str(step) + " Minibatch Loss= " + "{:.3f}".format(loss) + ", Training Loss= " + "{:.3f}".format(old_div(train_loss[0],batch_size)) + ", Base Training Loss= " + "{:.3f}".format(old_div(train_loss[1],batch_size))) trainData['train_err'].append(old_div(train_loss[0],batch_size)) trainData['val_err'].append(loss) trainData['step_no'].append(step) if step % conf.save_step == 0: saver1.save(sess,outfilename,global_step=step, latest_filename = conf.ckptfinename) print('Saved state to %s-%d' %(outfilename,step)) tdfile = open(traindatafilename,'wb') pickle.dump(trainData,tdfile) tdfile.close() # if step % conf.save_step == 0: # curoutname = '%s_%d.ckpt'% (outname,step) # outfilename = os.path.join(conf.cachedir,curoutname) # saver1.save(sess,outfilename) # print('Saved state to %s' %(outfilename)) step += 1 print("Optimization Finished!") saver1.save(sess,outfilename,global_step=step, latest_filename = conf.ckptfinename) print('Saved state to %s-%d' %(outfilename,step)) tdfile = open(traindatafilename,'wb') pickle.dump(trainData,tdfile) tdfile.close() sess.close()
def testPrepareSessionSucceeds(self): with tf.Graph().as_default(): v = tf.Variable([1.0, 2.0, 3.0], name="v") sm = tf.train.SessionManager(ready_op=tf.assert_variables_initialized()) sess = sm.prepare_session("", init_op=tf.initialize_all_variables()) self.assertAllClose([1.0, 2.0, 3.0], sess.run(v))