def model(x, y, batch_size, is_training=True, reuse=None): with tf.variable_scope('model', reuse=reuse): x_tensor = tf.reshape(x, [-1, 28, 28, 1]) fc1 = fc(x, 20, is_training, reuse, name='fc1', activation=None) fc1 = tf.tanh(fc1) fc1 = dropout(fc1, is_training, drop_p=0.5) fc2 = fc(fc1, 6, is_training, reuse, use_bias=False, name='fc2') initial = np.array([[1., 0, 0], [0, 1., 0]]) initial = initial.astype('float32') initial = initial.flatten() fc2_b = tf.Variable(initial_value=initial, name='fc2/b') fc2 = tf.nn.bias_add(fc2, bias=fc2_b) fc2 = tf.tanh(fc2) h_trans = spatialtransformer(x_tensor, fc2, batch_size=batch_size) conv1 = conv2d(h_trans, 16, is_training, reuse, activation=prelu, name='conv1') conv2 = conv2d(conv1, 16, is_training, reuse, stride=(2, 2), activation=prelu, name='conv2') fcmain = fc(conv2, 1024, is_training, reuse, name='fc', activation=prelu) fcmain = dropout(fcmain, is_training, drop_p=0.5) logits = fc(fcmain, 10, is_training, reuse, name='logits', activation=None) prediction = softmax(logits, 'prediction') loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=logits, labels=y)) opt = tf.train.AdamOptimizer() optimizer = opt.minimize(loss) # grads = opt.compute_gradients(loss, [fc2_b]) correct_prediction = tf.equal(tf.argmax(prediction, 1), tf.argmax(y, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, 'float')) return accuracy, loss, optimizer
def model(inputs, is_training, reuse, num_classes=2): common_args = common_layer_args(is_training, reuse) conv1 = conv2d(inputs, 32, name='conv1', activation=prelu, **common_args) conv1 = conv2d(conv1, 32, name='conv2', activation=prelu, **common_args) fc1 = fc(conv1, num_classes, name='logits', **common_args) prediction = softmax(fc1, name='prediction', **common_args) return end_points(is_training)
def model(x, is_training, reuse): common_args = common_layer_args(is_training, reuse) fc_args = make_args(activation=relu, **common_args) logit_args = make_args(activation=None, **common_args) x = embedding(x, 10000, 128, reuse) x = lstm(x, 34, reuse, is_training) logits = fc(x, 2, name='logits', **logit_args) predictions = softmax(logits, name='predictions', **common_args) return end_points(is_training)
def model(x, is_training, reuse, num_classes=2, **kwargs): common_args = common_layer_args(is_training, reuse) fc_args = make_args(activation=relu, **common_args) logit_args = make_args(activation=None, **common_args) x = embedding(x, 10000, 128, reuse) x = bidirectional_rnn(x, LSTMCell(128, reuse), LSTMCell(128, reuse), **common_args) logits = fc(x, num_classes, name='logits', **logit_args) predictions = softmax(logits, name='predictions', **common_args) return end_points(is_training)
def model(input_data, target, num_hidden=34, is_training=True, reuse=None): cell = LSTMCell(num_hidden, reuse) val, _ = tf.nn.dynamic_rnn(cell, input_data, dtype=tf.float32) val = tf.transpose(val, [1, 0, 2]) last = tf.gather(val, int(val.get_shape()[0]) - 1) logit = fc(last, int(target.get_shape()[1]), is_training, reuse) prediction = tf.nn.softmax(logit) loss = - \ tf.reduce_sum( target * tf.log(tf.clip_by_value(prediction, 1e-10, 1.0))) optimizer = tf.train.AdamOptimizer() train_op = optimizer.minimize(loss) error = tf.not_equal(tf.argmax(target, 1), tf.argmax(prediction, 1)) error = tf.reduce_mean(tf.cast(error, tf.float32)) return prediction, error, train_op
def model(x, is_training, reuse, num_classes=2, **kwargs): common_args = common_layer_args(is_training, reuse) fc_args = make_args(activation=relu, **common_args) logit_args = make_args(activation=None, **common_args) x = embedding(x, 10000, 128, reuse) x1 = conv1d(x, 128, name='conv1_1', **common_args) x2 = conv1d(x, 128, filter_size=4, name='conv1_2', **common_args) x3 = conv1d(x, 128, filter_size=5, name='conv1_3', **common_args) x = merge([x1, x2, x3], 'concat', axis=1) x = lstm(x, 384, reuse, is_training) x = dropout(x, drop_p=0.3, **common_args) logits = fc(x, num_classes, name='logits', **logit_args) predictions = softmax(logits, name='predictions', **common_args) return end_points(is_training)
def model(x, is_training, reuse): common_args = common_layer_args(is_training, reuse) fc_args = make_args(activation=relu, **common_args) logit_args = make_args(activation=None, **common_args) x = embedding(x, 10000, 128, reuse) x1 = conv1d(x, 128, name='conv1_1', **common_args) x2 = conv1d(x, 128, filter_size=4, name='conv1_2', **common_args) x3 = conv1d(x, 128, filter_size=5, name='conv1_3', **common_args) x = merge([x1, x2, x3], 'concat', axis=1) x = tf.expand_dims(x, 2) x = global_max_pool(x) x = dropout(x, drop_p=0.3, **common_args) logits = fc(x, 2, name='logits', **logit_args) predictions = softmax(logits, name='predictions', **common_args) return end_points(is_training)
def model(inputs, is_training, reuse, num_classes=5, dropout_keep_prob=0.5, spatial_squeeze=True, name='alexnet_v2', **kwargs): """AlexNet version 2. Described in: http://arxiv.org/pdf/1404.5997v2.pdf Parameters from: github.com/akrizhevsky/cuda-convnet2/blob/master/layers/ layers-imagenet-1gpu.cfg Note: All the fully_connected layers have been transformed to conv2d layers. To use in classification mode, resize input to 224x224. To use in fully convolutional mode, set spatial_squeeze to false. The LRN layers have been removed and change the initializers from random_normal_initializer to xavier_initializer. Args: inputs: a tensor of size [batch_size, height, width, channels]. num_classes: number of predicted classes. is_training: whether or not the model is being trained. dropout_keep_prob: the probability that activations are kept in the dropout layers during training. spatial_squeeze: whether or not should squeeze the spatial dimensions of the outputs. Useful to remove unnecessary dimensions for classification. name: Optional name for the variables. Returns: the last op containing the log predictions and end_points dict. """ common_args = common_layer_args(is_training, reuse) conv_args = make_args(batch_norm=True, activation=prelu, w_init=initz.he_normal(scale=1), untie_biases=False, **common_args) logit_args = make_args(activation=None, w_init=initz.he_normal(scale=1), **common_args) pred_args = make_args(activation=prelu, w_init=initz.he_normal(scale=1), **common_args) pool_args = make_args(padding='SAME', **common_args) # inputs = input((None, crop_size[1], crop_size[0], 3), **common_args) with tf.variable_scope(name, 'alexnet_v2', [inputs]): net = conv2d(inputs, 64, filter_size=(11, 11), stride=(4, 4), name='conv1', **conv_args) net = max_pool(net, stride=(2, 2), name='pool1', **pool_args) net = conv2d(net, 192, filter_size=(5, 5), name='conv2', **conv_args) net = max_pool(net, stride=(2, 2), name='pool2', **pool_args) net = conv2d(net, 384, name='conv3', **conv_args) net = conv2d(net, 384, name='conv4', **conv_args) net = conv2d(net, 256, name='conv5', **conv_args) net = max_pool(net, stride=(2, 2), name='pool5', **pool_args) # Use conv2d instead of fully_connected layers. net = conv2d(net, 4096, filter_size=(5, 5), name='fc6', **conv_args) net = dropout(net, drop_p=1 - dropout_keep_prob, name='dropout6', **common_args) net = conv2d(net, 4096, filter_size=(1, 1), name='fc7', **conv_args) net = dropout(net, drop_p=1 - dropout_keep_prob, name='dropout7', **common_args) net = global_avg_pool(net) logits = fc(net, num_classes, name='logits', **logit_args) predictions = softmax(logits, name='predictions', **common_args) return end_points(is_training)
def model(height, width, num_actions, is_training=False, reuse=None, name=None): common_args = common_layer_args(is_training, reuse) conv_args = make_args(batch_norm=True, activation=prelu, w_init=initz.he_normal(scale=1), untie_biases=False, **common_args) logits_args = make_args(activation=None, w_init=initz.he_normal(scale=1), **common_args) fc_args = make_args(activation=prelu, w_init=initz.he_normal(scale=1), **common_args) pool_args = make_args(padding='SAME', **common_args) with tf.variable_scope(name): state = register_to_collections(tf.placeholder( shape=[None, 4, height, width], dtype=tf.float32, name='state'), name='state', **common_args) state_perm = tf.transpose(state, perm=[0, 2, 3, 1]) summary_ops = [ tf.summary.image("states", state[:, 0, :, :][..., tf.newaxis], max_outputs=10, collections='train') ] conv1_0 = conv2d(state_perm, 32, filter_size=8, stride=(1, 1), name="conv1_0", **conv_args) conv1_1 = conv2d(conv1_0, 64, filter_size=8, stride=(2, 2), name="conv1_1", **conv_args) pool = max_pool(conv1_1, filter_size=2, name="maxpool", **pool_args) conv2_0 = conv2d(pool, 128, filter_size=4, stride=2, name="conv2_0", **conv_args) conv2_1 = conv2d(conv2_0, 256, filter_size=3, stride=(2, 2), name="conv2_1", **conv_args) conv3_0 = conv2d(conv2_1, 256, filter_size=4, stride=1, name="conv3_0", **conv_args) conv3_1 = conv2d(conv3_0, 512, filter_size=4, stride=2, name="conv3_1", **conv_args) # Dueling value_hid = fc(conv3_1, 512, name="value_hid", **fc_args) adv_hid = fc(conv3_1, 512, name="adv_hid", **fc_args) value = fc(value_hid, 1, name="value", **logits_args) advantage = fc(adv_hid, num_actions, name="advantage", **logits_args) # Average Dueling Qs = value + (advantage - tf.reduce_mean(advantage, axis=1, keep_dims=True)) # action with highest Q values a = register_to_collections(tf.argmax(Qs, 1), name='a', **common_args) # Q value belonging to selected action Q = register_to_collections(tf.reduce_max(Qs, 1), name='Q', **common_args) summary_ops.append(tf.summary.histogram("Q", Q, collections='train')) # For training Q_target = register_to_collections(tf.placeholder(shape=[None], dtype=tf.float32), name='Q_target', **common_args) actions = register_to_collections(tf.placeholder(shape=[None], dtype=tf.int32), name='actions', **common_args) actions_onehot = tf.one_hot(actions, num_actions, on_value=1., off_value=0., axis=1, dtype=tf.float32) Q_tmp = tf.reduce_sum(tf.multiply(Qs, actions_onehot), axis=1) loss = register_to_collections(tf.reduce_mean( tf.square(Q_target - Q_tmp)), name='loss', **common_args) summary_ops.append(tf.summary.scalar("loss", loss, collections='train')) register_to_collections(summary_ops, name='summary_ops', **common_args) return end_points(is_training)