def dice_loss_dict(y_true, y_pred): smooth = 1e-6 dict={} for i in range(args.num_classes): y_true_f_1 = layers.flatten(y_true[...,i]) y_pred_f_1 = layers.flatten(y_pred[...,i]) intersection = tf.reduce_sum(y_true_f_1 * y_pred_f_1) if i==0: key_name = 'dice loss on background: ' else: key_name = 'dice loss on class {}: '.format(i) dict[key_name] = 1- (2. * intersection + smooth) / (tf.reduce_sum(y_true_f_1 * y_true_f_1) + tf.reduce_sum(y_pred_f_1 * y_pred_f_1) + smooth) return dict
def fourier_dqn_network(min_vals, max_vals, num_actions, state, fourier_basis_order=3): """Builds the function approximator used to compute the agent's Q-values. It uses FourierBasis features and a linear layer. Args: min_vals: float, minimum attainable values (must be same shape as `state`). max_vals: float, maximum attainable values (must be same shape as `state`). num_actions: int, number of actions. state: `tf.Tensor`, contains the agent's current state. fourier_basis_order: int, order of the Fourier basis functions. Returns: The Q-values for DQN-style agents or logits for Rainbow-style agents. """ net = tf.cast(state, tf.float32) net = layers.flatten(net) # Feed state through Fourier basis. feature_generator = FourierBasis( net.get_shape().as_list()[-1], min_vals, max_vals, order=fourier_basis_order) net = feature_generator.compute_features(net) # Q-values are always linear w.r.t. last layer. q_values = layers.fully_connected( net, num_actions, activation_fn=None, biases_initializer=None) return q_values
def _basic_discrete_domain_network(min_vals, max_vals, num_actions, state, num_atoms=None): """Builds a basic network for discrete domains, rescaling inputs to [-1, 1]. Args: min_vals: float, minimum attainable values (must be same shape as `state`). max_vals: float, maximum attainable values (must be same shape as `state`). num_actions: int, number of actions. state: `tf.Tensor`, the state input. num_atoms: int or None, if None will construct a DQN-style network, otherwise will construct a Rainbow-style network. Returns: The Q-values for DQN-style agents or logits for Rainbow-style agents. """ net = tf.cast(state, tf.float32) net = layers.flatten(net) net -= min_vals net /= max_vals - min_vals net = 2.0 * net - 1.0 # Rescale in range [-1, 1]. net = layers.fully_connected(net, 512) net = layers.fully_connected(net, 512) if num_atoms is None: # We are constructing a DQN-style network. return layers.fully_connected(net, num_actions, activation_fn=None) else: # We are constructing a Rainbow-style network. return layers.fully_connected( net, num_actions * num_atoms, activation_fn=None)
def _cnn(self, x): x = tf.cast(x, tf.float32) / 255. x = layers.conv2d(x, filters=32, kernel_size=8, strides=(4, 4), kernel_initializer=init, activation=tf.nn.relu) x = layers.conv2d(x, filters=64, kernel_size=4, strides=(2, 2), kernel_initializer=init, activation=tf.nn.relu) x = layers.conv2d(x, filters=64, kernel_size=3, strides=(1, 1), kernel_initializer=init, activation=tf.nn.relu) x = layers.flatten(x) return layers.dense(x, units=512, kernel_initializer=init, activation=tf.nn.relu)
def build(self): """ Build the MLP model. """ # keep_prob = tf.cond(tf.equal(self.is_training, tf.constant(True)), lambda: self.k_prob, lambda: 1.0) with tf.variable_scope(self.name): incoming = layers.flatten(self.incoming) input_layer = layers.dense(incoming, self.n_in, kernel_initializer=he_init, bias_initializer=b_init) input_layer = tf.layers.batch_normalization(input_layer) input_layer = tf.nn.relu(input_layer) hidden_layer = layers.dense(input_layer, self.n_hidden, kernel_initializer=he_init, bias_initializer=b_init) hidden_layer = tf.layers.batch_normalization(hidden_layer) hidden_layer = tf.nn.relu(hidden_layer) output_layer = layers.dense(hidden_layer, self.n_out, bias_initializer=b_init) output_layer = tf.layers.batch_normalization(output_layer) # final activation: linear return output_layer
def discriminatorNet(inputs, is_training, use_batchNorm): idx = 0 f = inputs f = layers.conv2d(f, 64, kernel_size=4, strides=2, padding="SAME", name="conv_%d" % idx) if use_batchNorm: f = layers.batch_normalization(f, training=is_training, name="bn_%d" % idx) f = tf.nn.leaky_relu(f, alpha=0.01, name="lrelu_%d" % idx) idx += 1 f = layers.conv2d(f, 128, kernel_size=4, strides=2, padding="SAME", name="conv_%d" % idx) if use_batchNorm: f = layers.batch_normalization(f, training=is_training, name="bn_%d" % idx) f = tf.nn.leaky_relu(f, alpha=0.01, name="lrelu_%d" % idx) idx += 1 f = layers.flatten(f) f = layers.dense(f, 1024, name="dense_%d" % idx) f = tf.nn.leaky_relu(f, alpha=0.01, name="lrelu_%d" % idx) return f
def misconception_model(inputs, filters_list, kernel_size, strides_list, training, objective_functions, sub_filters=128, sub_layers=2, dropout_rate=0.5, virtual_batch_size=None, feature_means=None, feature_stds=None): """ A misconception tower. Args: input: a tensor of size [batch_size, 1, width, depth]. window_size: the width of the conv and pooling filters to apply. depth: the depth of the output tensor. levels: the height of the tower in misconception layers. objective_functions: a list of objective functions to add to the top of the network. is_training: whether the network is training. Returns: a tensor of size [batch_size, num_classes]. """ layers = [] net = inputs if feature_means is not None: net = net - tf.constant(feature_means)[None, None, :] if feature_stds is not None: net = net / (tf.constant(feature_stds) + 1e-6) layers.append(net) for filters, strides in zip(filters_list, strides_list): net = misconception_with_bypass(net, filters, kernel_size, strides, training, virtual_batch_size=virtual_batch_size) layers.append(net) outputs = [] for ofunc in objective_functions: onet = net for _ in range(sub_layers - 1): onet = ly.conv1d(onet, sub_filters, 1, activation=None, use_bias=False) onet = ly.batch_normalization( onet, training=training, virtual_batch_size=virtual_batch_size) onet = tf.nn.relu(onet) onet = ly.conv1d(onet, sub_filters, 1, activation=tf.nn.relu) onet = ly.flatten(onet) # onet = ly.dropout(onet, training=training, rate=dropout_rate) outputs.append(ofunc.build(onet)) return outputs, layers
def Encoder(inputs, is_training): with tf.variable_scope('Encoder'): conv_0 = CONV_BN_ACT(inputs=inputs, filters=32, kernel_size=[3,3], strides=[1,1], padding='same', act_fn='lrelu', is_training=is_training, is_transpose=False) conv_1 = CONV_BN_ACT(inputs=conv_0, filters=64, kernel_size=[3,3], strides=[2,2], padding='same', act_fn='lrelu', is_training=is_training, is_transpose=False) conv_2 = CONV_BN_ACT(inputs=conv_1, filters=128, kernel_size=[3,3], strides=[2,2], padding='same', act_fn='lrelu', is_training=is_training, is_transpose=False) flat = flatten(conv_2) z_mean = dense(inputs=flat, units=z_dim) z_log_var = dense(inputs=flat, units=z_dim) return z_mean, z_log_var
def build_discriminator(image, reuse=False): with tf.variable_scope("discriminator") as scope: if reuse: tf.get_variable_scope().reuse_variables() # t = image t = conv2d(inputs=t, filters=64, kernel_size=[5, 5], strides=2, padding="same", activation=my_leaky_relu) t = batch_normalization(inputs=t) t = conv2d(inputs=t, filters=128, kernel_size=[5, 5], strides=2, padding="same", activation=my_leaky_relu) t = batch_normalization(inputs=t) t = dropout(inputs=t, rate=DROP_RATE) t = flatten(inputs=t) t = dense(inputs=t, units=1, activation=tf.sigmoid) decision = t #print("\nD output shape: {}".format(decision.shape)) return decision
def build(self): """ Build the model. """ with tf.variable_scope(self.name): incoming = layers.flatten(self.incoming) input_layer = layers.dense(incoming, self.n_in, kernel_initializer=he_init, bias_initializer=b_init) input_layer = tf.layers.batch_normalization( input_layer, training=self.is_training) input_layer = tf.nn.relu(input_layer) hidden_layer = layers.dense(input_layer, self.n_hidden, kernel_initializer=he_init, bias_initializer=b_init) hidden_layer = tf.layers.batch_normalization( hidden_layer, training=self.is_training) hidden_layer = tf.nn.relu(hidden_layer) output_layer = layers.dense(hidden_layer, self.n_out, bias_initializer=b_init) output_layer = tf.layers.batch_normalization( output_layer, training=self.is_training) output_layer = tf.nn.relu(output_layer) # final activation: linear self.prediction = output_layer return self
def _build_critic_network(self, state_in, name, reuse=False, batch_size=1): w_reg = None # tf.contrib.layers.l2_regularizer(L2_REGULARIZATION) with tf.variable_scope(name, reuse=reuse): serial_net = layers.flatten(state_in) serial_net = layers.dense(serial_net, 256) serial_net = layers.dense(serial_net, RNN_UNIT_SIZE) # LSTM layer lstm = tf.nn.rnn_cell.LSTMCell(num_units=RNN_UNIT_SIZE, name='lstm_cell') #lstm = tf.nn.rnn_cell.ResidualWrapper(lstm) #lstm = tf.nn.rnn_cell.DropoutWrapper(lstm, output_keep_prob=self.keep_prob_) lstm = tf.nn.rnn_cell.MultiRNNCell([lstm] * RNN_NUM_LAYERS) init_state = lstm.zero_state(batch_size=batch_size, dtype=tf.float32) lstm_in = tf.expand_dims(serial_net, axis=0) rnn_net, final_state = tf.nn.dynamic_rnn(cell=lstm, inputs=lstm_in, initial_state=init_state) rnn_net = tf.reshape(rnn_net, [-1, RNN_UNIT_SIZE], name='flatten_rnn_outputs') critic = layers.dense( serial_net, 1, kernel_initializer=normalized_columns_initializer(1.0), kernel_regularizer=w_reg, name="critic_out") params = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope=self.scope + '/' + name) return critic, params, init_state, final_state
def vgg_11(x, keep_proba, is_train, num_classes): # https://arxiv.org/abs/1409.1556 --> configuration A w_ini, b_ini, r_ini = initializers(conf.bias_init, conf.l2_str) x_multichannel = tf.reshape( x, [-1, conf.img_dim[0], conf.img_dim[1], conf.num_ch]) net = _conv2d(x_multichannel, 64, 3, 'conv1') net = max_pooling2d(net, 2, 2, 'same', name='maxpool1') net = _conv2d(net, 128, 3, 'conv2') net = max_pooling2d(net, 2, 2, 'same', name='maxpool2') net = _conv2d(net, 256, 3, 'conv3_1') net = _conv2d(net, 256, 3, 'conv3_2') net = max_pooling2d(net, 2, 2, 'same', name='maxpool3') net = _conv2d(net, 512, 3, 'conv4_1') net = _conv2d(net, 512, 3, 'conv4_2') net = max_pooling2d(net, 2, 2, 'same', name='maxpool4') net = _conv2d(net, 512, 3, 'conv5_1') net = _conv2d(net, 512, 3, 'conv5_2') net = max_pooling2d(net, 2, 2, 'same', name='maxpool5') net = flatten(net, name='flat_layer') net = _dense(net, 4096, 'fc6') net = tf.nn.dropout(net, keep_proba, name='dropout6') net = _dense(net, 4096, 'fc7') net = tf.nn.dropout(net, keep_proba, name='dropout7') # # TODO consider replacing fc layers by conv layers # # as in https://github.com/tensorflow/models/blob/master/research/slim/nets/vgg.py # # for "if include_top" see https://github.com/keras-team/keras-applications/blob/master/keras_applications/vgg16.py # net = _conv2d(net, 4096, 7, 'fc6_replacement', padding='VALID') # net = tf.nn.dropout(net, keep_proba, name='dropout7') # net = _conv2d(net, 4096, 1, 'fc7_replacement') # net = tf.reduce_mean(net, axis=[1, 2], name='global_avg_pool8') logits = _dense(net, conf.num_cl, 'logits', activation=None) # softmax performed at loss function return logits
def decode(self, z, x_dim, training=False): im_h, im_w, im_c = self.image_shape with tf.variable_scope("decoder", reuse=tf.AUTO_REUSE): h = z h = tfl.dense(h, units=self.h_dim, activation=tf.nn.relu) h = tfl.dense(h, units=self.h_dim, activation=tf.nn.relu) stride = 16 h = tfl.dense( h, units=im_h // stride * im_w // stride * self.kernel_num * 2, activation=tf.nn.relu) new_shape = (-1, im_h // stride, im_w // stride, self.kernel_num * 2) h = tf.reshape(h, new_shape) h = tfl.conv2d_transpose( h, self.kernel_num * 2, self.kernel_size, strides=2, padding="same", activation=tf.nn.relu) h = tfl.conv2d_transpose( h, self.kernel_num, self.kernel_size, strides=2, padding="same", activation=tf.nn.relu) h = tfl.conv2d_transpose( h, self.kernel_num, self.kernel_size, strides=2, padding="same", activation=tf.nn.relu) h = tfl.conv2d_transpose( h, im_c, self.kernel_size, strides=2, padding="same", activation=tf.nn.sigmoid) h = tfl.flatten(h) y_mean = h return y_mean
def __init__(self, model_name): self.state_size = state_size self.action_size = action_size self.input = tf.placeholder(shape=[None, self.state_size[0], self.state_size[1], self.state_size[2]], dtype=tf.float32) self.input_normalize = (self.input - (255.0 / 2)) / (255.0 / 2) with tf.variable_scope(name_or_scope=model_name): self.conv1 = layer.conv2d(inputs=self.input_normalize,filters=32, activation=tf.nn.relu,kernel_size=[8,8], strides=[4,4],padding="SAME") self.conv2 = layer.conv2d(inputs=self.conv1,filters=64, activation=tf.nn.relu,kernel_size=[4,4], strides=[2,2],padding="SAME") self.conv3 = layer.conv2d(inputs=self.conv2,filters=64, activation=tf.nn.relu,kernel_size=[3,3], strides=[1,1],padding="SAME") self.flat = layer.flatten(self.conv3) self.fc1 = layer.dense(self.flat,512,activation=tf.nn.relu) self.Q_Out = layer.dense(self.fc1,self.action_size,activation=None) self.predict = tf.argmax(self.Q_Out, 1) self.target_Q = tf.placeholder(shape=[None, self.action_size], dtype=tf.float32) self.loss = tf.losses.huber_loss(self.target_Q, self.Q_Out) self.UpdateModel = tf.train.AdamOptimizer(learning_rate).minimize(self.loss) self.trainable_var = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, model_name)
def _model_fn(self, input_shape, output_shape): X = tf.placeholder(tf.float32, (None, ) + input_shape, name="state") Y = tf.placeholder(tf.float32, (None, ) + output_shape, name="action_true") nn = X nn = L.conv2d(nn, 32, 8, strides=4, name="block1/conv1", activation=N.relu) nn = L.conv2d(nn, 64, 4, strides=2, name="block2/conv1") nn = L.conv2d(nn, 64, 3, strides=1, name="block3/conv1") nn = L.flatten(nn, name="flatten") nn = L.dense(nn, 512, activation=N.relu, name="fc1") value = L.dense(nn, 64, activation=N.relu, name="value_fc2") value = L.dense(value, 1, name="value") advantage = L.dense(nn, 64, activation=N.relu, name="advantage_fc2") advantage = L.dense(advantage, output_shape[0], name="advantage") q = tf.add( value, (advantage - tf.reduce_mean(advantage, axis=1, keepdims=True)), name="action") Y_pred = q return X, Y, Y_pred
def classifier_net(inputs, scope, reuse=None): with tf.variable_scope(scope, reuse=reuse): net = conv2d(inputs, filters=32, kernel_size=5, strides=1, activation=tf.nn.leaky_relu, name='conv1') net = conv2d(net, filters=64, kernel_size=3, strides=1, activation=tf.nn.leaky_relu, name='conv2') net = max_pooling2d(net, pool_size=2, strides=2, padding='same', name='maxpool1') net = conv2d(net, filters=64, kernel_size=3, strides=1, activation=tf.nn.leaky_relu, name='conv3') net = max_pooling2d(net, pool_size=2, strides=2, padding='same', name='maxpool2a') net = conv2d(net, filters=64, kernel_size=3, strides=1, activation=tf.nn.leaky_relu, name='conv4') net = max_pooling2d(net, pool_size=2, strides=2, padding='same', name='maxpool2') net = conv2d(net, filters=64, kernel_size=3, strides=1, activation=tf.nn.leaky_relu, name='conv5') net = max_pooling2d(net, pool_size=2, strides=2, padding='same', name='maxpool3a') net = conv2d(net, filters=64, kernel_size=3, strides=1, activation=tf.nn.leaky_relu, name='conv6') net = max_pooling2d(net, pool_size=2, strides=2, padding='same', name='maxpool3') net = conv2d(net, filters=32, kernel_size=3, strides=1, activation=tf.nn.leaky_relu, name='conv7') net = max_pooling2d(net, pool_size=2, strides=2, padding='same', name='maxpool4') net = flatten(net, name='flatten') # net = dense(net, 1024, activation=tf.nn.leaky_relu, name='dense1') # net = batch_normalization(net) net = dense(net, 512, activation=tf.nn.leaky_relu, name='dense2') # net = batch_normalization(net) net = dense(net, 256, activation=tf.nn.leaky_relu, name='dense3') # net = batch_normalization(net) net = dense(net, 128, activation=tf.nn.leaky_relu, name='dense4') net = dense(net, 1, activation=tf.nn.sigmoid, name='out') return net
def __call__(self, input_obs): with tf.variable_scope("default_conv_net"): inputs = input_obs for i, (filters_, kernel_size, stride, padding) in enumerate(self._conv_filters): inputs = layers.conv2d(inputs=inputs, filters=filters_, kernel_size=kernel_size, strides=stride, padding=padding, activation=self._activation, name="conv{}".format(i)) hidden = layers.flatten(inputs) if self._input_action: hidden = tf.concat([hidden, self._input_action], axis=1) logits = layers.dense(hidden, units=self._action_dim, activation=None, name="logits") if self._need_v: logits_to_v = layers.dense(hidden, units=32, activation=tf.nn.relu, name="logits_to_value") v = layers.dense(logits_to_v, units=1, activation=None, name="value") v = tf.squeeze(v, [-1]) return ( logits, v, ) return logits
def _model(self, inputs, mode, **config): x = inputs['image'] if config['data_format'] == 'channels_first': x = tf.transpose(x, [0, 3, 1, 2]) params = {'padding': 'SAME', 'data_format': config['data_format']} x = tfl.conv2d(x, 32, 5, activation=tf.nn.relu, name='conv1', **params) x = tfl.max_pooling2d(x, 2, 2, name='pool1', **params) x = tfl.conv2d(x, 64, 5, activation=tf.nn.relu, name='conv2', **params) x = tfl.max_pooling2d(x, 2, 2, name='pool2', **params) x = tfl.flatten(x) x = tfl.dense(x, 1024, activation=tf.nn.relu, name='fc1') x = tfl.dense(x, 10, name='fc2') if mode == Mode.TRAIN: return {'logits': x} else: return { 'logits': x, 'prob': tf.nn.softmax(x), 'pred': tf.argmax(x, axis=-1) }
def __discriminator__(self, image_input): with tf.variable_scope("discriminator", reuse=tf.AUTO_REUSE): cnn1 = layers.conv2d(image_input, filters=64, kernel_size=5, strides=(2, 2), padding="SAME") cnn1 = tf.nn.leaky_relu(cnn1) cnn2 = layers.conv2d(cnn1, filters=128, kernel_size=5, strides=(2, 2), padding="SAME") cnn2 = tf.nn.leaky_relu(cnn2) cnn3 = layers.conv2d(cnn2, filters=256, kernel_size=5, strides=(2, 2), padding="SAME") cnn3 = tf.nn.leaky_relu(cnn3) logits = layers.dense(layers.flatten(cnn3), 1) #print_Arch: print("Discriminator-Architecture") print("input:{}".format(image_input.shape)) print("cnn1:{}".format(cnn1.shape)) print("cnn2:{}".format(cnn2.shape)) print("cnn3:{}".format(cnn3.shape)) print("output:{}".format(logits.shape)) return logits
def encode(self, x, z_dim, training=False): im_h, im_w, im_c = self.image_shape with tf.variable_scope("encoder", reuse=tf.AUTO_REUSE): h = x h = tf.reshape(h, (-1, im_h, im_w, im_c)) # TODO: h = tfl.conv2d( h, self.kernel_num, self.kernel_size, strides=1, padding="same") h = tf.nn.relu(h) h = tfl.conv2d( h, self.kernel_num, self.kernel_size, strides=2, padding="same") h = tf.nn.relu(h) # TODO: tu troche zmienilem h = tfl.conv2d( h, self.kernel_num * 2, self.kernel_size, strides=2, padding="same") h = tf.nn.relu(h) h = tfl.conv2d( h, self.kernel_num * 2, self.kernel_size, strides=2, padding="same") h = tf.nn.relu(h) h = tfl.flatten(h) h = tfl.dense(h, units=self.h_dim, activation=tf.nn.relu) z_mean = tfl.dense(h, units=z_dim, name='z_mean') # z_mean = tfl.batch_normalization(z_mean, training=training) return z_mean
def __init__(self, state_size, action_size): self.states = tf.placeholder(tf.float32, shape=[None, *state_size], name="states") self.labels = tf.placeholder( tf.int32, shape=[None, 1], name="labels") # size 1 because sparse loss is used. # conv1 = layers.conv2d(self.states, filters=16, kernel_size=(8, 8), strides=(4, 4), activation='relu', # name="conv1"), # conv2 = layers.conv2d(conv1, filters=32, kernel_size=(4, 4), strides=(2, 2), activation='relu', name="conv2"), # flatten = layers.flatten(conv2), # dense = layers.dense(flatten, 256, activation='relu', name="features"), # # self.logits = layers.dense(dense, action_size, name="logits") # self.value = layers.dense(dense, 1, name="values") # conv1 = conv2d(self.states, filters=32, kernel_size=(3, 3), name='conv1') with tf.variable_scope('layers'): conv1 = layers.conv2d(self.states, filters=32, kernel_size=(3, 3), activation='relu', name='conv1') conv2 = layers.conv2d(conv1, filters=64, kernel_size=(3, 3), activation='relu', name='conv2') max_pool = layers.max_pooling2d(conv2, 2, 1, name='max_pool') drop_1 = layers.dropout(max_pool, 0.25, name='drop1') flatten = layers.flatten(drop_1, name='flatten') dense = layers.dense(flatten, 128, activation='relu', name='dense') drop2 = layers.dropout(dense, 0.5, name='drop2') logits = layers.dense(drop2, action_size, activation='softmax', name='logits') self.output = tf.nn.softmax(logits, name='output') # tf.one_hot(tf.arg_max(self.output, 1), depth=10) print(tf.arg_max(self.output, 1)) self.test = tf.one_hot(tf.arg_max(self.output, 1), depth=10) # input() self.cost = tf.losses.sparse_softmax_cross_entropy(self.labels, logits) self.acc, self.acc_op = tf.metrics.accuracy(self.labels, tf.arg_max(self.output, 1)) # self.grad = tf.gradients(self.cost, self.states, stop_gradients=[self.states]) self.grad = tf.gradients(self.cost, tf.trainable_variables()) self.optimizer = tf.train.AdamOptimizer() # print(tf.trainable_variables()) # print(tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='layers')) # print(self.grad) self.apply_grad = self.optimizer.apply_gradients( zip( self.grad, tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='layers')))
def resnet18(x, num_classes, training): x = conv2d(x, 64, 7, padding=PADDING, strides=2, data_format=DATA_FORMAT, name='conv1') x = group_normalization(x, 'gn0', 32) # x = group_norm(x, 32, channels_axis=-3, reduction_axes=[-2, -1]) # x = batch_norm(x, decay=0.9, scale=True, is_training=training, epsilon=BN_EPS, data_format='NCHW') x = tf.nn.relu(x) stage = [2, 2, 2, 2] channels = [64, 128, 256, 512] for i, s, c in zip(list(range(4)), stage, channels): for l in range(s): stride = 1 if l > 0 else 2 proj = False if l > 0 else True x = create_residual_block('res_block_{}_{}'.format(i + 1, l + 1), x, c, stride=stride, proj=proj, training=training) # BxCx1x1 x = flatten(x) x = slim.fully_connected(x, num_classes, activation_fn=None) return x
def weighted_accuracy(y_true, y_pred): correct_prediction = layers.flatten(y_pred) # correct_prediction = tf.reduce_min(y_pred, axis=-1) correct_prediction = tf.greater(correct_prediction,0.5) # correct_prediction = tf.equal(tf.argmax(y_pred, axis=-1), y_ture_tmp) correct_prediction = tf.cast(correct_prediction, tf.float32) # correct_prediction.shape = (1, 256, 256, 16) y_true = layers.flatten(y_true) # y_true = tf.reduce_min(y_true, axis=-1) correct_partial = tf.multiply(correct_prediction, y_true) accuracy = tf.reduce_sum(correct_partial)/tf.reduce_sum(y_true) incorrect_partial = tf.multiply((1.-correct_prediction),(1.- y_true)) inaccuracy = tf.reduce_sum(incorrect_partial)/tf.reduce_sum(1.-y_true) return accuracy, inaccuracy
def _dense_brick(incoming, is_training, scope='dense_brick'): """ Dense brick: flatten --> fully connected --> batch normalization --> leaky relu. """ with tf.variable_scope(scope): flat = layers.flatten(incoming) fc = layers.dense(flat, units=32) fc_bn = layers.batch_normalization(fc, training=is_training) fc_act = tf.nn.leaky_relu(fc_bn) return fc_act
def pretrained_classifier(inputae, n_label, reuse, name='classifier', isTrain = False, n_filters = 64, output_bias=None): print("Classifier", isTrain) if output_bias is not None: output_bias = tf.constant_initializer(output_bias) padw = 3 with tf.variable_scope(name) as scope: if reuse: tf.get_variable_scope().reuse_variables() else: assert tf.get_variable_scope().reuse is False print("inputae: ", inputae) pad_input = tf.pad(inputae, [[0, 0], [padw, padw], [padw, padw], [0, 0]], "CONSTANT") #print("pad_input: ", pad_input) conv1, _conv, _bn = conv_2d_BN_Relu(pad_input, n_filters, 7, 2, 'VALID',isTrain) #print("conv1: ", conv1) padw = 1 pad_conv1 = tf.pad(conv1, [[0, 0], [padw, padw], [padw, padw], [0, 0]], "CONSTANT") #print("pad_conv1: ", pad_conv1) pool1 = Max_Pooling(pad_conv1, pool_size=[3,3], stride=2) #print("pool1: ", pool1) # Block 1 block1 = dense_block(pool1, nb_layers=6, layer_name='dense_1', isTrain=isTrain, filters=n_filters) transition1 = transition_layer(block1, isTrain, scope='trans_1') #print("block1 output: ", transition1) #print("............................") block2 = dense_block(transition1, nb_layers=12, layer_name='dense_2', isTrain=isTrain, filters=n_filters) transition2 = transition_layer(block2, isTrain, scope='trans_2') #print("block2 output: ", transition2) #print("............................") block3 = dense_block(transition2, nb_layers=24, layer_name='dense_3', isTrain=isTrain, filters=n_filters) transition3 = transition_layer(block3, isTrain, scope='trans_3') #print("block3 output: ", transition3) #print("............................") block4 = dense_block(transition3, nb_layers=16, layer_name='dense_final', isTrain=isTrain, filters=n_filters) #print("block4 output: ", block4) #print("............................") bn = batch_norm(block4, is_training=isTrain, name='linear_batch') print("bn final: ", bn) rel = tf.nn.relu(bn) shape = rel.get_shape().as_list() #print(shape) gap = Average_pooling(rel, pool_size=[shape[1],shape[2]], stride=1) #gap = Average_pooling(rel, pool_size=[7,7], stride=1) #print("global avg pooling final: ", gap) flat = flatten(gap) #print("flat: ", flat) logit = tf.layers.dense(flat, units=n_label, bias_initializer= output_bias, name='linear') #print("logit: ", logit) if isTrain == False: #print(isTrain) logit = tf.stop_gradient(logit) prediction = tf.nn.sigmoid(logit) #pred_y = tf.argmax(prediction, 1) return logit, prediction
def build_network(self, img_placeholder): x = img_placeholder x = self.basic_conv2d(x, 32, kernel_size=3, stride=2, padding="same", namescope="conv2d_1a", use_bias=False) x = self.basic_conv2d(x, 32, kernel_size=3, stride=1, padding="same", namescope="conv2d_2a", use_bias=False) x = self.basic_conv2d(x, 64, kernel_size=3, stride=1, padding="same", namescope="conv2d_2b", use_bias=False) x = self.basic_conv2d(x, 80, kernel_size=1, stride=1, padding="same", namescope="conv2d_3b", use_bias=False) x = self.basic_conv2d(x, 192, kernel_size=3, stride=1, padding="same", namescope="conv2d_4a", use_bias=False) x = self.mixed_5b(x) x = self.mixed_6a(x) x = self.mixed_7a(x) x = self.block8(x) x = self.basic_conv2d(x, 1536, kernel_size=1, stride=1, padding="same", namescope="conv2d_7b", use_bias=False) x = layers.average_pooling2d(x, 8, strides=8, padding="valid") x = layers.flatten(x) logits = layers.dense(x, self.n_classes, name="last_linear") probs = tf.nn.softmax(logits) return logits, probs
def vgg_11_1d(x, keep_proba, conf): def _dense(inputs, neurons, name, activation=tf.nn.relu, use_bias=True): """wrapper function for dense layer""" w_ini, b_ini, r_ini = initializers(conf.bias_init, conf.l2_str) return dense(inputs, neurons, activation=activation, bias_initializer=b_ini, kernel_initializer=w_ini, kernel_regularizer=r_ini, name=name, use_bias=use_bias) def _conv1d(inputs, n_filters, size, name, padding='SAME'): """wrapper function for 1D convolutional layer""" w_ini, b_ini, r_ini = initializers(conf.bias_init, conf.l2_str) return conv1d(inputs, n_filters, size, padding=padding, activation=tf.nn.relu, bias_initializer=b_ini, kernel_initializer=w_ini, kernel_regularizer=r_ini, name=name) # https://arxiv.org/abs/1409.1556 --> configuration A w_ini, b_ini, r_ini = initializers(conf.bias_init, conf.l2_str) x_multichannel = tf.reshape(x, [-1, conf.seq_lngth, conf.num_ch]) net = _conv1d(x_multichannel, 64, 3, 'conv1') net = max_pooling1d(net, 2, 2, 'same', name='maxpool1') net = _conv1d(net, 128, 3, 'conv2') net = max_pooling1d(net, 2, 2, 'same', name='maxpool2') net = _conv1d(net, 256, 3, 'conv3_1') net = _conv1d(net, 256, 3, 'conv3_2') net = max_pooling1d(net, 2, 2, 'same', name='maxpool3') net = _conv1d(net, 512, 3, 'conv4_1') net = _conv1d(net, 512, 3, 'conv4_2') net = max_pooling1d(net, 2, 2, 'same', name='maxpool4') net = _conv1d(net, 512, 3, 'conv5_1') net = _conv1d(net, 512, 3, 'conv5_2') net = max_pooling1d(net, 2, 2, 'same', name='maxpool5') net = flatten(net, name='flat_layer') net = _dense(net, 4096, 'fc6') net = tf.nn.dropout(net, keep_proba, name='dropout6') net = _dense(net, 4096, 'fc7') net = tf.nn.dropout(net, keep_proba, name='dropout7') logits = _dense(net, conf.num_cl, 'logits', activation=None) # softmax performed at loss function return logits
def __init__(self, state_size, action_size, hidden_layer_size, learning_rate, name): if isinstance(state_size, list) and len(state_size) == 3: self.mode = 'visual' elif isinstance(state_size, int): self.mode = 'vector' self.state_size = state_size self.action_size = action_size self.hidden_size = hidden_layer_size self.name = name self.learning_rate = learning_rate with tf.variable_scope(name): if self.mode == 'visual': self.observation = tf.placeholder( tf.float32, shape=[None, *self.state_size], name="actor_observation") self.L1 = layer.conv2d(self.observation, 64, 3, activation=tf.nn.leaky_relu) self.L2 = layer.conv2d(self.L1, 64, 3, activation=tf.nn.leaky_relu) self.L3 = layer.flatten(self.L2) self.action = layer.dense(self.L3, self.action_size, activation=tf.nn.tanh, name='actor_decide') elif self.mode == 'vector': self.observation = tf.placeholder( tf.float32, shape=[None, self.state_size], name="actor_observation") self.L1 = layer.dense(self.observation, self.hidden_size, activation=tf.nn.leaky_relu) self.L2 = layer.dense(self.L1, self.hidden_size, activation=tf.nn.leaky_relu) self.L3 = layer.dense(self.L2, self.hidden_size, activation=tf.nn.leaky_relu) self.action = layer.dense(self.L3, self.action_size, activation=tf.nn.tanh, name='actor_decide') self.trainable_var = tf.get_collection( tf.GraphKeys.TRAINABLE_VARIABLES, self.name)
def Net(self, x, is_train): # 28*28*1 x = self.conv_net(x, 8, 3, 2, is_train, 'c0') # 13*13*8 x = self.conv_net(x, 32, 2, 2, is_train, 'c1') # 6*6*32 x = layer.flatten(x) # base_code 에서는 tensorflow.contrib.layers.fully_connected 를 사용했는데 tensorflow.contrib.layers는 잘 안씀. # tensorflow.layers를 보통 사용하고 여기선 tensorflow.layers.dense가 fully_connected와 동일. x = layer.dense(x, 200, activation=None, name='d1') x = tf.nn.relu(x) x = layer.dense(x, 10, activation=None, name='d3') return x
def discriminator(ten, dim, name, reuse=True): # ans = tf.placeholder(tf.float32, [None, C.size, C.size, 3]) with tf.variable_scope(name, reuse=reuse): ten = tl.conv2d(ten, dim * 1, 4, 2, 'same', activation=tf.nn.leaky_relu) ten = tl.conv2d(ten, dim * 2, 4, 2, 'same', activation=tf.nn.leaky_relu) ten = tl.conv2d(ten, dim * 4, 4, 2, 'same', activation=tf.nn.leaky_relu) ten = tl.conv2d(ten, dim * 8, 4, 2, 'same', activation=tf.nn.leaky_relu) ten = tl.conv2d(ten, dim * 16, 4, 2, 'same', activation=tf.nn.leaky_relu) ten = tl.conv2d(ten, dim * 32, 4, 2, 'same', activation=tf.nn.leaky_relu) ten = tl.conv2d(ten, dim * 64, 4, 1, 'valid', activation=tf.nn.leaky_relu) ten = tl.conv2d(ten, 1, 1, 1, 'valid', activation=None) ten = tl.flatten(ten) return ten