def model(self): """ To generate a model. :return: The estimation of race finish time of a single horse in centi second """ with tf.variable_scope(name_or_scope='race_predictor'): fc_0 = fc_layer(tf.layers.flatten(self._input), 256, training=self.training, name='fc_0') bi_0 = bilinear_layer(fc_0, 256, training=self.training, name='bi_0') bi_1 = bilinear_layer(bi_0, 256, training=self.training, name='bi_1') fc_1 = fc_layer(bi_1, 128, training=self.training, name='fc_1') win_output = tf.nn.softmax(tf.layers.dense(fc_1, units=14, activation=None), name='win_output') return win_output
def VGG16(x, n_classes, is_pretrain = True): x = utils.conv_layer('conv1_1', x, 64, filter = [3,3], strides = [1,1,1,1], is_pretrain = is_pretrain) x = utils.conv_layer('conv1_2', x, 64, filter = [3,3], strides = [1,1,1,1], is_pretrain = is_pretrain) x = utils.pool_layer('pool1', x, filter = [1,2,2,1], strides = [1,2,2,1], is_max_pool = True) x = utils.conv_layer('conv2_1', x, 128, filter = [3,3], strides = [1,1,1,1], is_pretrain = is_pretrain) x = utils.conv_layer('conv2_2', x, 128, filter = [3,3], strides = [1,1,1,1], is_pretrain = is_pretrain) x = utils.pool_layer('pool2', x, filter = [1,2,2,1], strides = [1,2,2,1], is_max_pool = True) x = utils.conv_layer('conv3_1', x, 256, filter=[3, 3], strides=[1, 1, 1, 1], is_pretrain=is_pretrain) x = utils.conv_layer('conv3_2', x, 256, filter=[3, 3], strides=[1, 1, 1, 1], is_pretrain=is_pretrain) x = utils.conv_layer('conv3_3', x, 256, filter=[3, 3], strides=[1, 1, 1, 1], is_pretrain=is_pretrain) x = utils.pool_layer('pool3', x, filter=[1,2,2,1], strides=[1,2,2,1], is_max_pool=True) x = utils.conv_layer('conv4_1', x, 512, filter=[3, 3], strides=[1, 1, 1, 1], is_pretrain=is_pretrain) x = utils.conv_layer('conv4_2', x, 512, filter=[3, 3], strides=[1, 1, 1, 1], is_pretrain=is_pretrain) x = utils.conv_layer('conv4_3', x, 512, filter=[3, 3], strides=[1, 1, 1, 1], is_pretrain=is_pretrain) x = utils.pool_layer('pool4', x, filter=[1,2,2,1], strides=[1,2,2,1], is_max_pool=True) x = utils.conv_layer('conv5_1', x, 512, filter=[3, 3], strides=[1, 1, 1, 1], is_pretrain=is_pretrain) x = utils.conv_layer('conv5_2', x, 512, filter=[3, 3], strides=[1, 1, 1, 1], is_pretrain=is_pretrain) x = utils.conv_layer('conv5_3', x, 512, filter=[3, 3], strides=[1, 1, 1, 1], is_pretrain=is_pretrain) x = utils.pool_layer('pool5', x, filter=[1, 2, 2, 1], strides=[1, 2, 2, 1], is_max_pool=True) x = utils.fc_layer('fc6', x, num_output = 4096) x = utils.batch_normalization(x) x = utils.fc_layer('fc7', x, num_output = 4096) x = utils.batch_normalization(x) x = utils.fc_layer('fc8', x, num_output = n_classes) return x
def critic(h): critic_h1 = utils.fc_layer(h, n_hidden[-1], 10, layer_name='critic_h1') out = utils.fc_layer(critic_h1, 10, 1, layer_name='critic_h2', act=tf.identity) return out
def forward(self, x, keep_prob): #DNN #第一层全连接层 hidden1 = fc_layer(x, self.input_dim, self.hidden_dim, 'layer1') #dropout hidden1 = dropout_layer(hidden1, keep_prob, 'layer1_dropout') #第二层全连接层 y = fc_layer(hidden1, self.hidden_dim, self.ouput_dim, 'layer2', act=tf.identity) return y
def forward(self, x): # rate2 = tf.placeholder(tf.float32) with tf.variable_scope("lstm1"): lstm_fw_cell = get_lstm(20, 1 - 0.3, name="lstm_fw") # Backward direction cell with tf.variable_scope("lstm2"): lstm_bw_cell = get_lstm(20, 1 - 0.3, name="lstm_bw") outputs, states = tf.nn.bidirectional_dynamic_rnn(cell_fw=lstm_fw_cell, cell_bw=lstm_bw_cell, dtype=tf.float32, inputs=x) output_fw, output_bw = outputs # states_fw, states_bw = states #print(output_fw,output_bw) #print(states_fw,states_bw) lstm_output = tf.concat([output_fw, output_bw], 2) #print(lstm_output.shape) #lstm_output = tf.reshape(lstm_output, [None, 8*40]) lstm_output = tf.layers.flatten(lstm_output) #print(lstm_output.shape) # 输出层 y = fc_layer(lstm_output, 8 * 40, 10, 'layer_after_lstm', act=tf.nn.sigmoid) return y
def forward(self, x): hidden = conv_layer(x, 5, 3, 6, self.regularizer) hidden = conv_layer(hidden, 3, 6, 12, self.regularizer) hidden = tf.reshape(hidden, [-1, 20 * 40 * 12]) y = fc_layer(hidden, 20 * 40 * 12, 10, 'layer_after_conv') return y
def model(self): """ To generate a model. :return: The estimation of race finish time of a single horse in centi second """ with tf.variable_scope(name_or_scope='race_predictor'): fc_0 = fc_layer(tf.layers.flatten(self._input), 512, training=self.training, name='fc_0') bi_0 = bilinear_layer(fc_0, 512, training=self.training, name='bi_0') bi_1 = bilinear_layer(bi_0, 512, training=self.training, name='bi_1') velocity_output = tf.layers.dense(bi_1, units=1, activation=None, use_bias=False, name='velocity_output') alpha_output = tf.layers.dense(bi_1, units=1, activation=None, use_bias=False, name='alpha_output') return velocity_output, alpha_output
def naive_model(self): with tf.variable_scope(name_or_scope='game_rating'): # pre-processing layers fc_0 = fc_layer(self._features, 128, training=self.training, name='fc_0') # bi-linear layers bi_0 = bilinear_layer(fc_0, 128, training=self.training, name='bi_0') # output layer playtime_output = fc_layer(bi_0, 1, training=self.training, name='playtime_output') # return return playtime_output
def model(self): with tf.variable_scope(name_or_scope='game_rating'): # pre-processing layers semantic_fc_0 = fc_layer(tf.layers.flatten(self._semantic), 512, training=self.training, name='semantic_fc_0') features_fc_0 = fc_layer(self._features, 128, training=self.training, name='features_fc_0') # bi-linear layers semantic_bi_0 = bilinear_layer(semantic_fc_0, 512, training=self.training, name='semantic_bi_0') features_bi_0 = bilinear_layer(features_fc_0, 128, training=self.training, name='features_bi_0') # post-processing layers semantic_fc_1 = fc_layer(semantic_bi_0, 128, training=self.training, name='semantic_fc_1') features_fc_1 = fc_layer(features_bi_0, 128, training=self.training, name='features_fc_1') # merge user features and movie features by an add_n operation, following by a fully-connected layer merge = tf.multiply(semantic_fc_1, features_fc_1, name='merge') # merge = tf.add_n([semantic_fc_1, features_fc_1], name='merge') # output layer playtime_output = fc_layer(merge, 1, training=self.training, name='playtime_output') # return return playtime_output
l2_param = 1e-5 lr = 1e-4 batch_size = 64 num_steps = 1200 num_class = 10 n_input = 4096 n_hidden = [500, 100] with tf.name_scope('input'): X = tf.placeholder(dtype=tf.float32) y_true = tf.placeholder(dtype=tf.int32) train_flag = tf.placeholder(dtype=tf.bool) y_true_one_hot = tf.one_hot(y_true, num_class) with tf.name_scope('generator'): h1 = utils.fc_layer(X, n_input, n_hidden[0], layer_name='hidden1') h2 = utils.fc_layer(h1, n_hidden[0], n_hidden[1], layer_name='hidden2') with tf.name_scope('slice_data'): h2_s = tf.cond(train_flag, lambda: tf.slice(h2, [0, 0], [batch_size / 2, -1]), lambda: h2) h2_t = tf.cond(train_flag, lambda: tf.slice(h2, [batch_size / 2, 0], [batch_size / 2, -1]), lambda: h2) ys_true = tf.cond(train_flag, lambda: tf.slice(y_true_one_hot, [0, 0], [batch_size / 2, -1]), lambda: y_true_one_hot) with tf.name_scope('classifier'): W_clf = tf.Variable(tf.truncated_normal([n_hidden[-1], num_class], stddev=1. / tf.sqrt(n_hidden[-1] / 2.)), name='clf_weight') b_clf = tf.Variable(tf.constant(0.1, shape=[num_class]), name='clf_bias') pred_logit = tf.matmul(h2_s, W_clf) + b_clf pred_softmax = tf.nn.softmax(pred_logit) clf_loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred_logit, labels=ys_true)) clf_acc = tf.reduce_mean(tf.cast(tf.equal(tf.argmax(y_true_one_hot, 1), tf.argmax(pred_softmax, 1)), tf.float32))
l2_param = 1e-5 lr = 1e-4 batch_size = 64 num_steps = 1200 num_class = 10 n_input = 4096 n_hidden = [500, 100] with tf.name_scope('input'): X = tf.placeholder(dtype=tf.float32) y_true = tf.placeholder(dtype=tf.int32) train_flag = tf.placeholder(dtype=tf.bool) y_true_one_hot = tf.one_hot(y_true, num_class) h1 = utils.fc_layer(X, n_input, n_hidden[0], layer_name='hidden1') h2 = utils.fc_layer(h1, n_hidden[0], n_hidden[1], layer_name='hidden2') with tf.name_scope('slice_data'): h2_s = tf.cond(train_flag, lambda: tf.slice(h2, [0, 0], [batch_size / 2, -1]), lambda: h2) h2_t = tf.cond( train_flag, lambda: tf.slice(h2, [batch_size / 2, 0], [batch_size / 2, -1]), lambda: h2) ys_true = tf.cond( train_flag, lambda: tf.slice(y_true_one_hot, [0, 0], [batch_size / 2, -1]), lambda: y_true_one_hot)
b_fc2 = utils.bias_variable([10], 'fc2_bias') pred_logit = tf.matmul(h_s, W_fc2) + b_fc2 clf_loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits=pred_logit, labels=ys_true)) clf_acc = tf.reduce_mean( tf.cast(tf.equal(tf.argmax(ys_true, 1), tf.argmax(pred_logit, 1)), tf.float32)) alpha = tf.random_uniform(shape=[batch_size / 2, 1], minval=0., maxval=1.) differences = h_s - h_t interpolates = h_t + (alpha * differences) h2_whole = tf.concat([h_fc1, interpolates], 0) with tf.name_scope('critic'): critic_h1 = utils.fc_layer(h2_whole, 1024, 100, layer_name='critic_h1') critic_out = utils.fc_layer(critic_h1, 100, 1, layer_name='critic_h2', act=tf.identity) critic_s = tf.cond(train_flag, lambda: tf.slice(critic_out, [0, 0], [batch_size / 2, -1]), lambda: critic_out) critic_t = tf.cond( train_flag, lambda: tf.slice(critic_out, [batch_size / 2, 0], [batch_size / 2, -1]), lambda: critic_out) wd_loss = (tf.reduce_mean(critic_s) - tf.reduce_mean(critic_t)) gradients = tf.gradients(critic_out, [h2_whole])[0]
def __init__(self, n_input, n_hidden, n_emb, num_class, clf_type, l2_w, net_pro_w, batch_size): self.X = tf.sparse_placeholder( dtype=tf.float32) #each node's own attributes self.X_nei = tf.sparse_placeholder( dtype=tf.float32) #each node's weighted neighbors' attributes self.y_true = tf.placeholder(dtype=tf.float32) self.d_label = tf.placeholder( dtype=tf.float32 ) #domain label, source network [1 0] or target network [0 1] self.Ada_lambda = tf.placeholder( dtype=tf.float32) #grl_lambda Gradient reversal scaler self.dropout = tf.placeholder(tf.float32) self.A_s = tf.sparse_placeholder( dtype=tf.float32) #network proximity matrix of source network self.A_t = tf.sparse_placeholder( dtype=tf.float32) #network proximity matrix of target network self.mask = tf.placeholder( dtype=tf.float32 ) #check a node is with observable label (1) or not (0) self.learning_rate = tf.placeholder(dtype=tf.float32) with tf.name_scope('Network_Embedding'): ##feature exactor 1 h1_self = utils.fc_layer(self.X, n_input, n_hidden[0], layer_name='hidden1_self', input_type='sparse', drop=self.dropout) h2_self = utils.fc_layer(h1_self, n_hidden[0], n_hidden[1], layer_name='hidden2_self') ##feature exactor 2 h1_nei = utils.fc_layer(self.X_nei, n_input, n_hidden[0], layer_name='hidden1_nei', input_type='sparse', drop=self.dropout) h2_nei = utils.fc_layer(h1_nei, n_hidden[0], n_hidden[1], layer_name='hidden2_nei') ##concatenation layer, final embedding vector representation self.emb = utils.fc_layer(tf.concat([h2_self, h2_nei], 1), n_hidden[-1] * 2, n_emb, layer_name='concat') ##pairwise constraint emb_s = tf.slice(self.emb, [0, 0], [int(batch_size / 2), -1]) emb_t = tf.slice(self.emb, [int(batch_size / 2), 0], [int(batch_size / 2), -1]) #L2 distance between source nodes r_s = tf.reduce_sum(emb_s * emb_s, 1) r_s = tf.reshape(r_s, [-1, 1]) Dis_s = r_s - 2 * tf.matmul( emb_s, tf.transpose(emb_s)) + tf.transpose(r_s) net_pro_loss_s = tf.reduce_mean( tf.sparse.reduce_sum(self.A_s.__mul__(Dis_s), axis=1)) #L2 distance between target nodes r_t = tf.reduce_sum(emb_t * emb_t, 1) r_t = tf.reshape(r_t, [-1, 1]) Dis_t = r_t - 2 * tf.matmul( emb_t, tf.transpose(emb_t)) + tf.transpose(r_t) net_pro_loss_t = tf.reduce_mean( tf.sparse.reduce_sum(self.A_t.__mul__(Dis_t), axis=1)) self.net_pro_loss = net_pro_w * (net_pro_loss_s + net_pro_loss_t) with tf.name_scope('Node_Classifier'): ##node classification W_clf = tf.Variable(tf.truncated_normal([n_emb, num_class], stddev=1. / tf.sqrt(n_emb / 2.)), name='clf_weight') b_clf = tf.Variable(tf.constant(0.1, shape=[num_class]), name='clf_bias') pred_logit = tf.matmul(self.emb, W_clf) + b_clf if clf_type == 'multi-class': ### multi-class, softmax output loss = tf.nn.softmax_cross_entropy_with_logits_v2( logits=pred_logit, labels=self.y_true) loss = loss * self.mask #count loss only based on labeled nodes self.clf_loss = tf.reduce_sum(loss) / tf.reduce_sum(self.mask) self.pred_prob = tf.nn.softmax(pred_logit) elif clf_type == 'multi-label': ### multi-label, sigmod output loss = tf.nn.sigmoid_cross_entropy_with_logits( logits=pred_logit, labels=self.y_true) loss = loss * self.mask[:, None] #count loss only based on labeled nodes, each column mutiply by mask self.clf_loss = tf.reduce_sum(loss) / tf.reduce_sum(self.mask) self.pred_prob = tf.sigmoid(pred_logit) with tf.name_scope('Domain_Discriminator'): h_grl = flip_gradient(self.emb, self.Ada_lambda) ##MLP for domain classification h_dann_1 = utils.fc_layer(h_grl, n_emb, 128, layer_name='dann_fc_1') h_dann_2 = utils.fc_layer(h_dann_1, 128, 128, layer_name='dann_fc_2') W_domain = tf.Variable(tf.truncated_normal([128, 2], stddev=1. / tf.sqrt(128 / 2.)), name='dann_weight') b_domain = tf.Variable(tf.constant(0.1, shape=[2]), name='dann_bias') d_logit = tf.matmul(h_dann_2, W_domain) + b_domain self.d_softmax = tf.nn.softmax(d_logit) self.domain_loss = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits_v2( logits=d_logit, labels=self.d_label)) all_variables = tf.trainable_variables() self.l2_loss = l2_w * tf.add_n( [tf.nn.l2_loss(v) for v in all_variables if 'bias' not in v.name]) self.total_loss = self.net_pro_loss + self.clf_loss + self.domain_loss + self.l2_loss self.train_op = tf.train.MomentumOptimizer( self.learning_rate, 0.9).minimize(self.total_loss)
num_class = 2 n_input = xs.shape[1] n_hidden = [500] tf.set_random_seed(0) np.random.seed(0) with tf.name_scope('input'): X = tf.sparse_placeholder(dtype=tf.float32) y_true = tf.placeholder(dtype=tf.int32) train_flag = tf.placeholder(dtype=tf.bool) y_true_one_hot = tf.one_hot(y_true, num_class) h1 = utils.fc_layer(X, n_input, n_hidden[0], layer_name='hidden1', input_type='sparse') with tf.name_scope('slice_data'): h1_s = tf.cond(train_flag, lambda: tf.slice(h1, [0, 0], [batch_size / 2, -1]), lambda: h1) h1_t = tf.cond( train_flag, lambda: tf.slice(h1, [batch_size / 2, 0], [batch_size / 2, -1]), lambda: h1) ys_true = tf.cond( train_flag, lambda: tf.slice(y_true_one_hot, [0, 0], [batch_size / 2, -1]), lambda: y_true_one_hot)
num_step = 5000 batch_size = 64 tf.set_random_seed(0) n_input = xs.shape[1] num_class = 2 n_hidden = [20] with tf.name_scope('input'): X = tf.placeholder(dtype=tf.float32) y_true = tf.placeholder(dtype=tf.int32) train_flag = tf.placeholder(dtype=tf.bool) y_true_one_hot = tf.one_hot(y_true, num_class) with tf.name_scope('generator'): h1 = utils.fc_layer(X, n_input, n_hidden[0], layer_name='hidden1', input_type='dense') with tf.name_scope('slice_data'): h1_s = tf.cond(train_flag, lambda: tf.slice(h1, [0, 0], [batch_size / 2, -1]), lambda: h1) h1_t = tf.cond(train_flag, lambda: tf.slice(h1, [batch_size / 2, 0], [batch_size / 2, -1]), lambda: h1) ys_true = tf.cond(train_flag, lambda: tf.slice(y_true_one_hot, [0, 0], [batch_size / 2, -1]), lambda: y_true_one_hot) with tf.name_scope('classifier'): W_clf = tf.Variable(tf.truncated_normal([n_hidden[-1], num_class], stddev=1. / tf.sqrt(n_hidden[-1] / 2.)), name='clf_weight') b_clf = tf.Variable(tf.constant(0.1, shape=[num_class]), name='clf_bias') pred_logit = tf.matmul(h1_s, W_clf) + b_clf pred_softmax = tf.nn.softmax(pred_logit) clf_loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred_logit, labels=ys_true)) clf_acc = tf.reduce_mean(tf.cast(tf.equal(tf.argmax(ys_true, 1), tf.argmax(pred_softmax, 1)), tf.float32)) alpha = tf.random_uniform(shape=[batch_size / 2, 1], minval=0., maxval=1.)
num_step = 10000 num_class = 2 n_input = xs.shape[1] n_hidden = [500] tf.set_random_seed(0) np.random.seed(0) with tf.name_scope('input'): X = tf.sparse_placeholder(dtype=tf.float32) y_true = tf.placeholder(dtype=tf.int32) train_flag = tf.placeholder(dtype=tf.bool) y_true_one_hot = tf.one_hot(y_true, num_class) with tf.name_scope('generator'): h1 = utils.fc_layer(X, n_input, n_hidden[0], layer_name='hidden1', input_type='sparse') with tf.name_scope('slice_data'): h1_s = tf.cond(train_flag, lambda: tf.slice(h1, [0, 0], [batch_size / 2, -1]), lambda: h1) ys_true = tf.cond(train_flag, lambda: tf.slice(y_true_one_hot, [0, 0], [batch_size / 2, -1]), lambda: y_true_one_hot) h1_t = tf.cond(train_flag, lambda: tf.slice(h1, [batch_size / 2, 0], [batch_size / 2, -1]), lambda: h1) with tf.name_scope('classifier'): W_clf = tf.Variable(tf.truncated_normal([n_hidden[-1], num_class], stddev=1. / tf.sqrt(n_hidden[-1] / 2.)), name='clf_weight') b_clf = tf.Variable(tf.constant(0.1, shape=[num_class]), name='clf_bias') pred_logit = tf.matmul(h1_s, W_clf) + b_clf pred_softmax = tf.nn.softmax(pred_logit) clf_loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=pred_logit, labels=ys_true)) clf_acc = tf.reduce_mean(tf.cast(tf.equal(tf.argmax(ys_true, 1), tf.argmax(pred_softmax, 1)), tf.float32)) clf_loss_sum = tf.summary.scalar('clf_loss', clf_loss) clf_acc_sum = tf.summary.scalar('clf_acc', clf_acc)
name=None) ''' hidden21 = conv_layer(pool20, [filter_size, filter_size, filter_nb_4, filter_nb_5], 'conv-17', stride, keep_prob, is_training, act=activation_func) hidden22 = conv_layer(hidden21, [filter_size, filter_size, filter_nb_5, filter_nb_5], 'conv-18', stride, keep_prob, is_training, act=activation_func) hidden23 = conv_layer(hidden22, [filter_size, filter_size, filter_nb_5, filter_nb_5], 'conv-19', stride, keep_prob, is_training, act=activation_func) hidden24 = conv_layer(hidden23, [filter_size, filter_size, filter_nb_5, filter_nb_5], 'conv-20', stride, keep_prob, is_training, act=activation_func) pool25 = tf.nn.max_pool(hidden24, [1, 3, 3, 1], [1, 3, 3, 1], padding='SAME', data_format='NHWC', name=None) ''' pool25 = tf.reshape(pool20, shape=[-1, 3 * 3 * filter_nb_4]) #fc14 = fc_layer(hidden17, [3 * 3 * filter_nb_4, 40], 'fc-1', keep_prob, is_training) y = fc_layer(pool25, [3 * 3 * filter_nb_4, template_dim], 'fc-1', keep_prob, act=None) ############################################# ################ THE LOSS ################### ############################################# """ Loss for regression """ with tf.name_scope('training'): euclidean_loss = tf.reduce_mean(tf.reduce_sum(tf.square(y - y_), axis=1)) tf.summary.scalar('train_euclidean_loss', euclidean_loss) """ Learning rate """ with tf.name_scope('learning_rate'): global_step = tf.Variable(0, trainable=False) learning_rate = tf.train.exponential_decay(inital_lr, global_step,