nets.py

#Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import paddle.fluid as fluid
Embedding=fluid.layers.embedding
FC=fluid.layers.fc
Cast=fluid.layers.cast
ReduceSum=fluid.layers.reduce_sum
Concat=fluid.layers.concat
Cosine=fluid.layers.cos_sim
ElemSub=fluid.layers.elementwise_sub
ElemDiv=fluid.layers.elementwise_div
ElemMax=fluid.layers.elementwise_max
ElemAdd=fluid.layers.elementwise_add
LessThan=fluid.layers.less_than
FillConst=fluid.layers.fill_constant
FillConstBatch=fluid.layers.fill_constant_batch_size_like
Mean=fluid.layers.mean
Data=fluid.layers.data

class BowEncoder(object):
    """ bow-encoder """
    def __init__(self):
        self.param_name = ""

    def forward(self, emb):
        return fluid.layers.sequence_pool(input=emb,
                                          pool_type='sum')

class CNNEncoder(object):
    """ cnn-encoder"""
    def __init__(self, 
                 param_name="cnn.w",
                 win_size=3,
                 ksize=128,
                 act='tanh',
                 pool_type='max'):
        self.param_name = param_name
        self.win_size = win_size
        self.ksize = ksize
        self.act = act
        self.pool_type = pool_type
        
    def forward(self, emb):
        return fluid.nets.sequence_conv_pool(
            input=emb,
            num_filters=self.ksize,
            filter_size=self.win_size,
            act=self.act,
            pool_type=self.pool_type,
            attr=self.param_name)

class GrnnEncoder(object):
    """ grnn-encoder """
    def __init__(self, 
                 param_name="grnn.w",
                 hidden_size=128):
        self.param_name = args
        self.hidden_size = hidden_size
    
    def forward(self, emb):
        gru_h = fluid.layers.dynamic_gru(input=emb,
                                         size=self.hidden_size,
                                         is_reverse=False,
                                         attr=self.param_name)
        return fluid.layers.sequence_pool(input=gru_h,
                                          pool_type='max')

class SimpleEncoderFactory(object):
    def __init__(self):
        pass

    def create(self, enc_type, enc_hid_size):
        if enc_type == "bow":
            bow_encode = BowEncoder()
            return bow_encode
        elif enc_type == "cnn":
            cnn_encode = CNNEncoder(ksize=enc_hid_size)
            return cnn_encode
        elif enc_type == "gru":
            rnn_encode = GrnnEncoder(hidden_size=enc_hid_size)
            return rnn_encode

class MultiviewSimnet(object):
    """ multi-view simnet """
    def __init__(self, 
                 embedding_size, 
                 embedding_dim,
                 hidden_size):
        self.embedding_size = embedding_size
        self.embedding_dim = embedding_dim
        self.emb_shape = [self.embedding_size, 
                          self.embedding_dim]
        self.hidden_size = hidden_size
        self.margin = 0.1

    def set_query_encoder(self, encoders):
        self.query_encoders = encoders

    def set_title_encoder(self, encoders):
        self.title_encoders = encoders

    def get_correct(self, x, y):
        less = Cast(LessThan(x, y), dtype='float32')
        correct = ReduceSum(less)
        return correct

    def train_net(self):
        # input fields for query, pos_title, neg_title
        q_slots = [Data(name="q%d" % i, shape=[1], lod_level=1, dtype='int64')
                   for i in range(len(self.query_encoders))]
        pt_slots = [Data(name="pt%d" % i, shape=[1], lod_level=1, dtype='int64') 
                    for i in range(len(self.title_encoders))]
        nt_slots = [Data(name="nt%d" % i, shape=[1], lod_level=1, dtype='int64') 
                    for i in range(len(self.title_encoders))]

        # lookup embedding for each slot
        q_embs = [Embedding(input=query, size=self.emb_shape,
                            param_attr="emb.w") for query in q_slots]
        pt_embs = [Embedding(input=title, size=self.emb_shape,
                             param_attr="emb.w") for title in pt_slots]
        nt_embs = [Embedding(input=title, size=self.emb_shape,
                             param_attr="emb.w") for title in nt_slots]
        
        # encode each embedding field with encoder
        q_encodes = [self.query_encoders[i].forward(emb)
                     for i, emb in enumerate(q_embs)]
        pt_encodes = [self.title_encoders[i].forward(emb)
                      for i, emb in enumerate(pt_embs)]
        nt_encodes = [self.title_encoders[i].forward(emb)
                      for i, emb in enumerate(nt_embs)]

        # concat multi view for query, pos_title, neg_title
        q_concat = Concat(q_encodes)
        pt_concat = Concat(pt_encodes)
        nt_concat = Concat(nt_encodes)

        # projection of hidden layer
        q_hid = FC(q_concat, size=self.hidden_size, param_attr='q_fc.w')
        pt_hid = FC(pt_concat, size=self.hidden_size, param_attr='t_fc.w')
        nt_hid = FC(nt_concat, size=self.hidden_size, param_attr='t_fc.w')

        # cosine of hidden layers
        cos_pos = Cosine(q_hid, pt_hid) 
        cos_neg = Cosine(q_hid, nt_hid)
        
        # pairwise hinge_loss
        loss_part1 = ElemSub(FillConstBatch(
            input=cos_pos, 
            shape=[-1, 1], 
            value=self.margin, 
            dtype='float32'), cos_pos)
        
        loss_part2 = ElemAdd(loss_part1, cos_neg)
        
        loss_part3 = ElemMax(FillConstBatch(
            input=loss_part2, 
            shape=[-1, 1], 
            value=0.0, 
            dtype='float32'), loss_part2)
        
        avg_cost = Mean(loss_part3)
        correct = self.get_correct(cos_pos, cos_neg)

        return q_slots + pt_slots + nt_slots, avg_cost, correct
        
    def pred_net(self, 
                 query_fields, 
                 pos_title_fields, 
                 neg_title_fields):
        q_slots = [Data(name="q%d" % i, shape=[1], lod_level=1, dtype='int64')
                   for i in range(len(self.query_encoders))]
        pt_slots = [Data(name="pt%d" % i, shape=[1], lod_level=1, dtype='int64') 
                    for i in range(len(self.title_encoders))]
        # lookup embedding for each slot
        q_embs = [Embedding(input=query, size=self.emb_shape,
                            param_attr="emb.w") for query in q_slots]
        pt_embs = [Embedding(input=title, size=self.emb_shape,
                             param_attr="emb.w") for title in pt_slots]
        # encode each embedding field with encoder
        q_encodes = [self.query_encoder[i].forward(emb)
                     for i, emb in enumerate(q_embs)]
        pt_encodes = [self.title_encoders[i].forward(emb)
                      for i, emb in enumerate(pt_embs)]
        # concat multi view for query, pos_title, neg_title
        q_concat = Concat(q_encodes)
        pt_concat = Concat(pt_encodes)
        # projection of hidden layer
        q_hid = FC(q_concat, size=self.hidden_size, param_attr='q_fc.w')
        pt_hid = FC(pt_concat, size=self.hidden_size, param_attr='t_fc.w')
        # cosine of hidden layers
        cos = Cosine(q_hid, pt_hid) 
        return cos