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 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
Exemplo n.º 3
0
 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
Exemplo n.º 4
0
 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