fix lambda_rank

ltr/lambda_rank.py

@@ -8,25 +8,25 @@ import numpy as np
 import paddle.v2 as paddle
 
 
-def lambda_rank(input_dim):
+def lambda_rank(input_dim, is_infer):
     """
-    lambda_rank is a Listwise rank model, the input data and label
+    Lambda_rank is a Listwise rank model, the input data and label
     must be sequences.
 
     https://papers.nips.cc/paper/2971-learning-to-rank-with-nonsmooth-cost-functions.pdf
     parameters :
       input_dim, one document's dense feature vector dimension
 
-    format of the dense_vector_sequence:
+    Format of the dense_vector_sequence:
     [[f, ...], [f, ...], ...], f is a float or an int number
     """
-
-    label = paddle.layer.data("label",
-                              paddle.data_type.dense_vector_sequence(1))
+    if not is_infer:
+        label = paddle.layer.data("label",
+                                  paddle.data_type.dense_vector_sequence(1))
     data = paddle.layer.data("data",
                              paddle.data_type.dense_vector_sequence(input_dim))
 
-    # hidden layer
+    # Define hidden layer.
     hd1 = paddle.layer.fc(
         input=data,
         size=128,
@@ -44,27 +44,30 @@ def lambda_rank(input_dim):
         act=paddle.activation.Linear(),
         param_attr=paddle.attr.Param(initial_std=0.01))
 
-    # evaluator
-    evaluator = paddle.evaluator.auc(input=output, label=label)
-    # cost layer
-    cost = paddle.layer.lambda_cost(
-        input=output, score=label, NDCG_num=6, max_sort_size=-1)
-    return cost, output
+    if not is_infer:
+        # Define evaluator.
+        evaluator = paddle.evaluator.auc(input=output, label=label)
+        # Define cost layer.
+        cost = paddle.layer.lambda_cost(
+            input=output, score=label, NDCG_num=6, max_sort_size=-1)
+        return cost, output
+    return output
 
 
 def train_lambda_rank(num_passes):
-    # listwise input sequence
+    # Listwise input sequence.
     fill_default_train = functools.partial(
         paddle.dataset.mq2007.train, format="listwise")
     fill_default_test = functools.partial(
         paddle.dataset.mq2007.test, format="listwise")
+
     train_reader = paddle.batch(
         paddle.reader.shuffle(fill_default_train, buf_size=100), batch_size=32)
     test_reader = paddle.batch(fill_default_test, batch_size=32)
 
-    # mq2007 input_dim = 46, dense format
+    # Training dataset: mq2007, input_dim = 46, dense format.
     input_dim = 46
-    cost, output = lambda_rank(input_dim)
+    cost, output = lambda_rank(input_dim, is_infer=False)
     parameters = paddle.parameters.create(cost)
 
     trainer = paddle.trainer.SGD(
@@ -72,7 +75,7 @@ def train_lambda_rank(num_passes):
         parameters=parameters,
         update_equation=paddle.optimizer.Adam(learning_rate=1e-4))
 
-    #  Define end batch and end pass event handler
+    #  Define end batch and end pass event handler.
     def event_handler(event):
         if isinstance(event, paddle.event.EndIteration):
             print "Pass %d Batch %d Cost %.9f" % (event.pass_id, event.batch_id,
@@ -93,30 +96,31 @@ def train_lambda_rank(num_passes):
 
 
 def lambda_rank_infer(pass_id):
-    """lambda_rank model inference interface
+    """Lambda rank model inference interface.
 
-    parameters:
+    Parameters:
         pass_id : inference model in pass_id
     """
     print "Begin to Infer..."
     input_dim = 46
-    output = lambda_rank(input_dim)
+    output = lambda_rank(input_dim, is_infer=True)
     parameters = paddle.parameters.Parameters.from_tar(
         gzip.open("lambda_rank_params_%d.tar.gz" % (pass_id - 1)))
 
     infer_query_id = None
     infer_data = []
     infer_data_num = 1
+
     fill_default_test = functools.partial(
         paddle.dataset.mq2007.test, format="listwise")
     for label, querylist in fill_default_test():
-        infer_data.append(querylist)
+        infer_data.append([querylist])
         if len(infer_data) == infer_data_num:
             break
 
-    # predict score of infer_data document.
-    # Re-sort the document base on predict score
-    # in descending order. then we build the ranking documents
+    # Predict score of infer_data document.
+    # Re-sort the document base on predict score.
+    # In descending order. then we build the ranking documents.
     predicitons = paddle.infer(
         output_layer=output, parameters=parameters, input=infer_data)
     for i, score in enumerate(predicitons):
@@ -129,7 +133,7 @@ if __name__ == '__main__':
     parser.add_argument(
         "--num_passes",
         type=int,
-        help="num of passes in train| infer pass number of model")
+        help="The Num of passes in train| infer pass number of model.")
     args = parser.parse_args()
     paddle.init(use_gpu=False, trainer_count=1)
     if args.run_type == "train":