关于Additive Ensembles of Regression Trees模型的快速打分预测

一.论文《QuickScorer:a Fast Algorithm to Rank Documents with Additive Ensembles of Regression Trees》是为了解决LTR模型的预测问题，如果LTR中的LambdaMart在生成模型时产生的树数和叶结点过多，在对样本打分预测时会遍历每棵树，这样在线上使用时效率较慢，这篇文章主要就是利用了bitvector方法加速打分预测。代码我找了很久没找到开源的，后来无意中在Solr ltr中看到被改动过了的源码，不过这个源码集成在solr中，这里暂时贴出来，后期再剥离出，集成到ranklib中，以便使用。

二.图片解说

1. Ensemble trees原始打分过程

像gbdt，lambdamart，xgboost或lightgbm等这样的集成树模型在打分预测阶段，比如来了一个样本，这个样本是vector形式输入到每一棵树中，然后在每棵树中像if else这样的过程走到或映射到每棵树的一个节点中，这个节点就是每棵树的打分，然后将每棵树的打分乘上学习率（shrinkage）加和就是此样本的预测分。

2.论文中提到的打分过程

A.为回归树中的每个分枝打上true和false标签

比如图中样本X=[0.2,1.1,0.2]，在回归树的branch中判断X[0],X[1],X[2]的true和false，比如图中根结点X[1]<=1.0，但样本X[1]=1.1，所以是false(走左边是true，右边是false)，这样将所有branch打上true和false标签（可以直接打上false标志，不用考虑true），后面需要用到所有的false branch。

B.为每个branch分配一个bitvector

这个bitvector中的"0"表示true leaves，比如"001111"表示6个叶结点中的最左边两个叶结点是候选节点。“110011”表示在右子树中true的结点只有中间两个，作为候选结点。

C.打分阶段

此阶段是最后的打分预测阶段，根据前几个图的过程，将所有branch为false的bitvector按位与操作，就会得出样本落在哪个叶结点上。比如图中的结果是"001101"，最左边为1的便是最终的叶结点的编号，每个回归树都会这样操作得到预测值，乘上学习率（shrinkage）然后加和就会得到一个样本的预测值。

三.代码

 import org.apache.lucene.index.LeafReaderContext;
 import org.apache.lucene.search.Explanation;
 import org.apache.solr.ltr.feature.Feature;
 import org.apache.solr.ltr.model.LTRScoringModel;
 import org.apache.solr.ltr.model.ModelException;
 import org.apache.solr.ltr.norm.Normalizer;
 import org.apache.solr.util.SolrPluginUtils;

 import java.util.*;

 public class MultipleAdditiveTreesModel extends LTRScoringModel {

     // 特征名：索引(从0开始)
     private final HashMap<String, Integer> fname2index = new HashMap();
     private List<RegressionTree> trees;

     private MultipleAdditiveTreesModel.RegressionTree createRegressionTree(Map<String, Object> map) {
         MultipleAdditiveTreesModel.RegressionTree rt = new MultipleAdditiveTreesModel.RegressionTree();
         if(map != null) {
             SolrPluginUtils.invokeSetters(rt, map.entrySet());
         }

         return rt;
     }

     private MultipleAdditiveTreesModel.RegressionTreeNode createRegressionTreeNode(Map<String, Object> map) {
         MultipleAdditiveTreesModel.RegressionTreeNode rtn = new MultipleAdditiveTreesModel.RegressionTreeNode();
         if(map != null) {
             SolrPluginUtils.invokeSetters(rtn, map.entrySet());
         }

         return rtn;
     }

     public void setTrees(Object trees) {
         this.trees = new ArrayList();
         Iterator var2 = ((List)trees).iterator();

         while(var2.hasNext()) {
             Object o = var2.next();
             MultipleAdditiveTreesModel.RegressionTree rt = this.createRegressionTree((Map)o);
             this.trees.add(rt);
         }
     }

     public void setTrees(List<RegressionTree> trees) {
         this.trees = trees;
     }

     public List<RegressionTree> getTrees() {
         return this.trees;
     }

     public MultipleAdditiveTreesModel(String name, List<Feature> features, List<Normalizer> norms, String featureStoreName, List<Feature> allFeatures, Map<String, Object> params) {
         super(name, features, norms, featureStoreName, allFeatures, params);

         for(int i = 0; i < features.size(); ++i) {
             String key = ((Feature)features.get(i)).getName();
             this.fname2index.put(key, Integer.valueOf(i));//特征名:索引
         }

     }

     public void validate() throws ModelException {
         super.validate();
         if(this.trees == null) {
             throw new ModelException("no trees declared for model " + this.name);
         } else {
             Iterator var1 = this.trees.iterator();

             while(var1.hasNext()) {
                 MultipleAdditiveTreesModel.RegressionTree tree = (MultipleAdditiveTreesModel.RegressionTree)var1.next();
                 tree.validate();
             }

         }
     }

     public float score(float[] modelFeatureValuesNormalized) {
         float score = 0.0F;

         MultipleAdditiveTreesModel.RegressionTree t;
         for(Iterator var3 = this.trees.iterator(); var3.hasNext(); score += t.score(modelFeatureValuesNormalized)) {
             t = (MultipleAdditiveTreesModel.RegressionTree)var3.next();
         }

         return score;
     }

     public Explanation explain(LeafReaderContext context, int doc, float finalScore, List<Explanation> featureExplanations) {
         float[] fv = new float[featureExplanations.size()];
         int index = 0;

         for(Iterator details = featureExplanations.iterator(); details.hasNext(); ++index) {
             Explanation featureExplain = (Explanation)details.next();
             fv[index] = featureExplain.getValue();
         }

         ArrayList var12 = new ArrayList();
         index = 0;

         for(Iterator var13 = this.trees.iterator(); var13.hasNext(); ++index) {
             MultipleAdditiveTreesModel.RegressionTree t = (MultipleAdditiveTreesModel.RegressionTree)var13.next();
             float score = t.score(fv);
             Explanation p = Explanation.match(score, "tree " + index + " | " + t.explain(fv), new Explanation[0]);
             var12.add(p);
         }

         return Explanation.match(finalScore, this.toString() + " model applied to features, sum of:", var12);
     }

     public String toString() {
         StringBuilder sb = new StringBuilder(this.getClass().getSimpleName());
         sb.append("(name=").append(this.getName());
         sb.append(",trees=[");

         for(int ii = 0; ii < this.trees.size(); ++ii) {
             if(ii > 0) {
                 sb.append(',');
             }

             sb.append(this.trees.get(ii));
         }

         sb.append("])");
         return sb.toString();
     }

     public class RegressionTree {
         private Float weight;
         private MultipleAdditiveTreesModel.RegressionTreeNode root;

         public void setWeight(float weight) {
             this.weight = new Float(weight);
         }

         public void setWeight(String weight) {
             this.weight = new Float(weight);
         }

         public float getWeight() {
             return this.weight;
         }

         public void setRoot(Object root) {
             this.root = MultipleAdditiveTreesModel.this.createRegressionTreeNode((Map)root);
         }

         public RegressionTreeNode getRoot() {
             return this.root;
         }

         public float score(float[] featureVector) {
             return this.weight.floatValue() * this.root.score(featureVector);
         }

         public String explain(float[] featureVector) {
             return this.root.explain(featureVector);
         }

         public String toString() {
             StringBuilder sb = new StringBuilder();
             sb.append("(weight=").append(this.weight);
             sb.append(",root=").append(this.root);
             sb.append(")");
             return sb.toString();
         }

         public RegressionTree() {
         }

         public void validate() throws ModelException {
             if(this.weight == null) {
                 throw new ModelException("MultipleAdditiveTreesModel tree doesn\'t contain a weight");
             } else if(this.root == null) {
                 throw new ModelException("MultipleAdditiveTreesModel tree doesn\'t contain a tree");
             } else {
                 this.root.validate();
             }
         }
     }

     public class RegressionTreeNode {
         private static final float NODE_SPLIT_SLACK = 1.0E-6F;
         private float value = 0.0F;
         private String feature;
         private int featureIndex = -1;
         private Float threshold;
         private MultipleAdditiveTreesModel.RegressionTreeNode left;
         private MultipleAdditiveTreesModel.RegressionTreeNode right;

         public void setValue(float value) {
             this.value = value;
         }

         public void setValue(String value) {
             this.value = Float.parseFloat(value);
         }

         public void setFeature(String feature) {
             this.feature = feature;
             Integer idx = (Integer)MultipleAdditiveTreesModel.this.fname2index.get(this.feature);
             this.featureIndex = idx == null?-1:idx.intValue();
         }

         public int getFeatureIndex() {
             return this.featureIndex;
         }

         public void setThreshold(float threshold) {
             this.threshold = Float.valueOf(threshold + 1.0E-6F);
         }

         public void setThreshold(String threshold) {
             this.threshold = Float.valueOf(Float.parseFloat(threshold) + 1.0E-6F);
         }

         public float getThreshold() {
             return this.threshold;
         }

         public void setLeft(Object left) {
             this.left = MultipleAdditiveTreesModel.this.createRegressionTreeNode((Map)left);
         }

         public RegressionTreeNode getLeft() {
             return this.left;
         }

         public void setRight(Object right) {
             this.right = MultipleAdditiveTreesModel.this.createRegressionTreeNode((Map)right);
         }

         public RegressionTreeNode getRight() {
             return this.right;
         }

         public boolean isLeaf() {
             return this.feature == null;
         }

         public float score(float[] featureVector) {
             return this.isLeaf()?this.value:(this.featureIndex >= 0 && this.featureIndex < featureVector.length?(featureVector[this.featureIndex] <= this.threshold.floatValue()?this.left.score(featureVector):this.right.score(featureVector)):0.0F);
         }

         public String explain(float[] featureVector) {
             if(this.isLeaf()) {
                 return "val: " + this.value;
             } else if(this.featureIndex >= 0 && this.featureIndex < featureVector.length) {
                 String rval;
                 if(featureVector[this.featureIndex] <= this.threshold.floatValue()) {
                     rval = "\'" + this.feature + "\':" + featureVector[this.featureIndex] + " <= " + this.threshold + ", Go Left | ";
                     return rval + this.left.explain(featureVector);
                 } else {
                     rval = "\'" + this.feature + "\':" + featureVector[this.featureIndex] + " > " + this.threshold + ", Go Right | ";
                     return rval + this.right.explain(featureVector);
                 }
             } else {
                 return "\'" + this.feature + "\' does not exist in FV, Return Zero";
             }
         }

         public String toString() {
             StringBuilder sb = new StringBuilder();
             if(this.isLeaf()) {
                 sb.append(this.value);
             } else {
                 sb.append("(feature=").append(this.feature);
                 sb.append(",threshold=").append(this.threshold.floatValue() - 1.0E-6F);
                 sb.append(",left=").append(this.left);
                 sb.append(",right=").append(this.right);
                 sb.append(')');
             }

             return sb.toString();
         }

         public RegressionTreeNode() {
         }

         public void validate() throws ModelException {
             if(this.isLeaf()) {
                 if(this.left != null || this.right != null) {
                     throw new ModelException("MultipleAdditiveTreesModel tree node is leaf with left=" + this.left + " and right=" + this.right);
                 }
             } else if(null == this.threshold) {
                 throw new ModelException("MultipleAdditiveTreesModel tree node is missing threshold");
             } else if(null == this.left) {
                 throw new ModelException("MultipleAdditiveTreesModel tree node is missing left");
             } else {
                 this.left.validate();
                 if(null == this.right) {
                     throw new ModelException("MultipleAdditiveTreesModel tree node is missing right");
                 } else {
                     this.right.validate();
                 }
             }
         }
     }

 }

 import org.apache.commons.lang.ArrayUtils;
 import org.apache.lucene.util.CloseableThreadLocal;
 import org.apache.solr.ltr.feature.Feature;
 import org.apache.solr.ltr.model.ModelException;
 import org.apache.solr.ltr.norm.Normalizer;

 import java.util.*;

 public class QuickScorerTreesModel extends MultipleAdditiveTreesModel{

     private static final long MAX_BITS = 0xFFFFFFFFFFFFFFFFL;

     // 64bits De Bruijn Sequence
     // see: http://chessprogramming.wikispaces.com/DeBruijnsequence#Binary alphabet-B(2, 6)
     private static final long HASH_BITS = 0x022fdd63cc95386dL;
     private static final int[] hashTable = new int[64];

     static {
         long hash = HASH_BITS;
         for (int i = 0; i < 64; ++i) {
             hashTable[(int) (hash >>> 58)] = i;
             hash <<= 1;
         }
     }

     /**
      * Finds the index of rightmost bit with O(1) by using De Bruijn strategy.
      *
      * @param bits target bits (64bits)
      * @see <a href="http://supertech.csail.mit.edu/papers/debruijn.pdf">http://supertech.csail.mit.edu/papers/debruijn.pdf</a>
      */
     private static int findIndexOfRightMostBit(long bits) {
         return hashTable[(int) (((bits & -bits) * HASH_BITS) >>> 58)];
     }

     /**
      * The number of trees of this model.
      */
     private int treeNum;

     /**
      * Weights of each tree.
      */
     private float[] weights;

     /**
      * List of all leaves of this model.
      * We use tree instead of value to manage wide (i.e., more than 64 leaves) trees.
      */
     private RegressionTreeNode[] leaves;

     /**
      * Offsets of each leaf block correspond to each tree.
      */
     private int[] leafOffsets;

     /**
      * The number of conditions of this model.
      */
     private int condNum;

     /**
      * Thresholds of each condition.
      * These thresholds are grouped by corresponding feature and each block is sorted by threshold values.
      */
     private float[] thresholds;

     /**
      * Corresponding featureIndex of each condition.
      */
     private int[] featureIndexes;

     /**
      * Offsets of each condition block correspond to each feature.
      */
     private int[] condOffsets;

     /**
      * Forward bitvectors of each condition which correspond to original additive trees.
      */
     private long[] forwardBitVectors;

     /**
      * Backward bitvectors of each condition which correspond to inverted additive trees.
      */
     private long[] backwardBitVectors;

     /**
      * Mappings from threasholdes index to tree indexes.
      */
     private int[] treeIds;

     /**
      * Bitvectors of each tree for calculating the score.
      * We reuse bitvectors instance in each thread to prevent from re-allocating arrays.
      */
     private CloseableThreadLocal<long[]> threadLocalTreeBitvectors = null;

     /**
      * Boolean statistical tendency of this model.
      * If conditions of the model tend to be false, we use inverted bitvectors for speeding up.
      */
     private volatile float falseRatio = 0.5f;

     /**
      * The decay factor for updating falseRatio in each evaluation step.
      * This factor is used like "{@code ratio = preRatio * decay  ratio * (1 - decay)}".
      */
     private float falseRatioDecay = 0.99f;

     /**
      * Comparable node cost for selecting leaf candidates.
      */
     private static class NodeCost implements Comparable<NodeCost> {
         private final int id;
         private final int cost;
         private final int depth;
         private final int left;
         private final int right;

         private NodeCost(int id, int cost, int depth, int left, int right) {
             this.id = id;
             this.cost = cost;
             this.depth = depth;
             this.left = left;
             this.right = right;
         }

         public int getId() {
             return id;
         }

         public int getLeft() {
             return left;
         }

         public int getRight() {
             return right;
         }

         /**
          * Sorts by cost and depth.
          * We prefer cheaper cost and deeper one.
          */
         @Override
         public int compareTo(NodeCost n) {
             if (cost != n.cost) {
                 return Integer.compare(cost, n.cost);
             } else if (depth != n.depth) {
                 return Integer.compare(n.depth, depth);  // revere order
             } else {
                 return Integer.compare(id, n.id);
             }
         }
     }

     /**
      * Comparable condition for constructing and sorting bitvectors.
      */
     private static class Condition implements Comparable<Condition> {
         private final int featureIndex;
         private final float threshold;
         private final int treeId;
         private final long forwardBitvector;
         private final long backwardBitvector;

         private Condition(int featureIndex, float threshold, int treeId, long forwardBitvector, long backwardBitvector) {
             this.featureIndex = featureIndex;
             this.threshold = threshold;
             this.treeId = treeId;
             this.forwardBitvector = forwardBitvector;
             this.backwardBitvector = backwardBitvector;
         }

         int getFeatureIndex() {
             return featureIndex;
         }

         float getThreshold() {
             return threshold;
         }

         int getTreeId() {
             return treeId;
         }

         long getForwardBitvector() {
             return forwardBitvector;
         }

         long getBackwardBitvector() {
             return backwardBitvector;
         }

         /*
          * Sort by featureIndex and threshold with ascent order.
          */
         @Override
         public int compareTo(Condition c) {
             if (featureIndex != c.featureIndex) {
                 return Integer.compare(featureIndex, c.featureIndex);
             } else {
                 return Float.compare(threshold, c.threshold);
             }
         }
     }

     /**
      * Base class for traversing node with depth first order.
      */
     private abstract static class Visitor {
         private int nodeId = 0;

         int getNodeId() {
             return nodeId;
         }

         void visit(RegressionTree tree) {
             nodeId = 0;
             visit(tree.getRoot(), 0);
         }

         private void visit(RegressionTreeNode node, int depth) {
             if (node.isLeaf()) {
                 doVisitLeaf(node, depth);
             } else {
                 // visit children first
                 visit(node.getLeft(), depth + 1);
                 visit(node.getRight(), depth + 1);

                 doVisitBranch(node, depth);
             }
             ++nodeId;
         }

         protected abstract void doVisitLeaf(RegressionTreeNode node, int depth);

         protected abstract void doVisitBranch(RegressionTreeNode node, int depth);
     }

     /**
      * {@link Visitor} implementation for calculating the cost of each node.
      */
     private static class NodeCostVisitor extends Visitor {

         private final Stack<AbstractMap.SimpleEntry<Integer, Integer>> idCostStack = new Stack<>();
         private final PriorityQueue<NodeCost> nodeCostQueue = new PriorityQueue<>();

         PriorityQueue<NodeCost> getNodeCostQueue() {
             return nodeCostQueue;
         }

         @Override
         protected void doVisitLeaf(RegressionTreeNode node, int depth) {
             nodeCostQueue.add(new NodeCost(getNodeId(), 0, depth, -1, -1));
             idCostStack.push(new AbstractMap.SimpleEntry<>(getNodeId(), 1));
         }

         @Override
         protected void doVisitBranch(RegressionTreeNode node, int depth) {
             // calculate the cost of this node from children costs
             final AbstractMap.SimpleEntry<Integer, Integer> rightIdCost = idCostStack.pop();
             final AbstractMap.SimpleEntry<Integer, Integer> leftIdCost = idCostStack.pop();
             final int cost = Math.max(leftIdCost.getValue(), rightIdCost.getValue());

             nodeCostQueue.add(new NodeCost(getNodeId(), cost, depth, leftIdCost.getKey(), rightIdCost.getKey()));
             idCostStack.push(new AbstractMap.SimpleEntry<>(getNodeId(), cost + 1));
         }
     }

     /**
      * {@link Visitor} implementation for extracting leaves and bitvectors.
      */
     private static class QuickScorerVisitor extends Visitor {

         private final int treeId;
         private final int leafNum;
         private final Set<Integer> leafIdSet;
         private final Set<Integer> skipIdSet;

         private final Stack<Long> bitsStack = new Stack<>();
         private final List<RegressionTreeNode> leafList = new ArrayList<>();
         private final List<Condition> conditionList = new ArrayList<>();

         private QuickScorerVisitor(int treeId, int leafNum, Set<Integer> leafIdSet, Set<Integer> skipIdSet) {
             this.treeId = treeId;
             this.leafNum = leafNum;
             this.leafIdSet = leafIdSet;
             this.skipIdSet = skipIdSet;
         }

         List<RegressionTreeNode> getLeafList() {
             return leafList;
         }

         List<Condition> getConditionList() {
             return conditionList;
         }

         private long reverseBits(long bits) {
             long revBits = 0L;
             long mask = (1L << (leafNum - 1));
             for (int i = 0; i < leafNum; ++i) {
                 if ((bits & mask) != 0L) revBits |= (1L << i);
                 mask >>>= 1;
             }
             return revBits;
         }

         @Override
         protected void doVisitLeaf(RegressionTreeNode node, int depth) {
             if (skipIdSet.contains(getNodeId())) return;

             bitsStack.add(1L << leafList.size());  // we use rightmost bit for detecting leaf
             leafList.add(node);
         }

         @Override
         protected void doVisitBranch(RegressionTreeNode node, int depth) {
             if (skipIdSet.contains(getNodeId())) return;

             if (leafIdSet.contains(getNodeId())) {
                 // an endpoint of QuickScorer
                 doVisitLeaf(node, depth);
                 return;
             }

             final long rightBits = bitsStack.pop();  // bits of false branch
             final long leftBits = bitsStack.pop();   // bits of true branch
       /*
        * NOTE:
        *   forwardBitvector  = ~leftBits
        *   backwardBitvector = ~(reverse(rightBits))
        */
             conditionList.add(
                     new Condition(node.getFeatureIndex(), node.getThreshold(), treeId, ~leftBits, ~reverseBits(rightBits)));
             bitsStack.add(leftBits | rightBits);
         }
     }

     public QuickScorerTreesModel(String name, List<Feature> features, List<Normalizer> norms, String featureStoreName,
                                  List<Feature> allFeatures, Map<String, Object> params) {
         super(name, features, norms, featureStoreName, allFeatures, params);
     }

     /**
      * Set falseRadioDecay parameter of this model.
      *
      * @param falseRatioDecay decay parameter for updating falseRatio
      */
     public void setFalseRatioDecay(float falseRatioDecay) {
         this.falseRatioDecay = falseRatioDecay;
     }

     /**
      * @see #setFalseRatioDecay(float)
      */
     public void setFalseRatioDecay(String falseRatioDecay) {
         this.falseRatioDecay = Float.parseFloat(falseRatioDecay);
     }

     /**
      * {@inheritDoc}
      */
     @Override
     public void validate() throws ModelException {
         // validate trees before initializing QuickScorer
         super.validate();

         // initialize QuickScorer with validated trees
         init(getTrees());
     }

     /**
      * Initializes quick scorer with given trees.
      * 利用给定的树集初始化快速打分模型
      *
      * @param trees base additive trees model
      */
     private void init(List<RegressionTree> trees) {
         this.treeNum = trees.size();
         this.weights = new float[trees.size()];
         this.leafOffsets = new int[trees.size() + 1];
         this.leafOffsets[0] = 0;

         // re-create tree bitvectors
         if (this.threadLocalTreeBitvectors != null) this.threadLocalTreeBitvectors.close();
         this.threadLocalTreeBitvectors = new CloseableThreadLocal<long[]>() {
             @Override
             protected long[] initialValue() {
                 return new long[treeNum];
             }
         };

         int treeId = 0;
         List<RegressionTreeNode> leafList = new ArrayList<>();
         List<Condition> conditionList = new ArrayList<>();
         for (RegressionTree tree : trees) {
             // select up to 64 leaves from given tree
             QuickScorerVisitor visitor = fitLeavesTo64bits(treeId, tree);

             // extract leaves and conditions with selected leaf candidates
             visitor.visit(tree);
             leafList.addAll(visitor.getLeafList());
             conditionList.addAll(visitor.getConditionList());

             // update weight, offset and treeId
             this.weights[treeId] = tree.getWeight();
             this.leafOffsets[treeId + 1] = this.leafOffsets[treeId] + visitor.getLeafList().size();
             ++treeId;
         }

         // remap list to array for performance reason
         this.leaves = leafList.toArray(new RegressionTreeNode[0]);

         // sort conditions by ascent order of featureIndex and threshold
         Collections.sort(conditionList);

         // remap information of conditions
         int idx = 0;
         int preFeatureIndex = -1;
         this.condNum = conditionList.size();
         this.thresholds = new float[conditionList.size()];
         this.forwardBitVectors = new long[conditionList.size()];
         this.backwardBitVectors = new long[conditionList.size()];
         this.treeIds = new int[conditionList.size()];
         List<Integer> featureIndexList = new ArrayList<>();
         List<Integer> condOffsetList = new ArrayList<>();
         for (Condition condition : conditionList) {
             this.thresholds[idx] = condition.threshold;
             this.forwardBitVectors[idx] = condition.getForwardBitvector();
             this.backwardBitVectors[idx] = condition.getBackwardBitvector();
             this.treeIds[idx] = condition.getTreeId();

             if (preFeatureIndex != condition.getFeatureIndex()) {
                 featureIndexList.add(condition.getFeatureIndex());
                 condOffsetList.add(idx);
                 preFeatureIndex = condition.getFeatureIndex();
             }

             ++idx;
         }
         condOffsetList.add(conditionList.size()); // guard

         this.featureIndexes = ArrayUtils.toPrimitive(featureIndexList.toArray(new Integer[0]));
         this.condOffsets = ArrayUtils.toPrimitive(condOffsetList.toArray(new Integer[0]));
     }

     /**
      * Checks costs of all nodes and select leaves up to 64.
      *
      * <p>NOTE:
      * We can use {@link java.util.BitSet} instead of {@code long} to represent bitvectors longer than 64bits.
      * However, this modification caused performance degradation in our experiments, and we decided to use this form.
      *
      * @param treeId index of given regression tree
      * @param tree target regression tree
      * @return QuickScorerVisitor with proper id sets
      */
     private QuickScorerVisitor fitLeavesTo64bits(int treeId, RegressionTree tree) {
         // calculate costs of all nodes
         NodeCostVisitor nodeCostVisitor = new NodeCostVisitor();
         nodeCostVisitor.visit(tree);

         // poll zero cost nodes (i.e., real leaves)
         Set<Integer> leafIdSet = new HashSet<>();
         Set<Integer> skipIdSet = new HashSet<>();
         while (!nodeCostVisitor.getNodeCostQueue().isEmpty()) {
             if (nodeCostVisitor.getNodeCostQueue().peek().cost > 0) break;
             NodeCost nodeCost = nodeCostVisitor.getNodeCostQueue().poll();
             leafIdSet.add(nodeCost.id);
         }

         // merge leaves until the number of leaves reaches 64
         while (leafIdSet.size() > 64) {
             final NodeCost nodeCost = nodeCostVisitor.getNodeCostQueue().poll();
             assert nodeCost.left >= 0 && nodeCost.right >= 0;

             // update leaves
             leafIdSet.remove(nodeCost.left);
             leafIdSet.remove(nodeCost.right);
             leafIdSet.add(nodeCost.id);

             // register previous leaves to skip ids
             skipIdSet.add(nodeCost.left);
             skipIdSet.add(nodeCost.right);
         }

         return new QuickScorerVisitor(treeId, leafIdSet.size(), leafIdSet, skipIdSet);
     }

     /**
      * {@inheritDoc}
      */
     @Override
     public float score(float[] modelFeatureValuesNormalized) {
         assert threadLocalTreeBitvectors != null;
         long[] treeBitvectors = threadLocalTreeBitvectors.get();
         Arrays.fill(treeBitvectors, MAX_BITS);

         int falseNum = 0;
         float score = 0.0f;
         if (falseRatio <= 0.5) {
             // use forward bitvectors
             for (int i = 0; i < condOffsets.length - 1; ++i) {
                 final int featureIndex = featureIndexes[i];
                 for (int j = condOffsets[i]; j < condOffsets[i + 1]; ++j) {
                     if (modelFeatureValuesNormalized[featureIndex] <= thresholds[j]) break;
                     treeBitvectors[treeIds[j]] &= forwardBitVectors[j];
                     ++falseNum;
                 }
             }

             for (int i = 0; i < leafOffsets.length - 1; ++i) {
                 final int leafIdx = findIndexOfRightMostBit(treeBitvectors[i]);
                 score += weights[i] * leaves[leafOffsets[i] + leafIdx].score(modelFeatureValuesNormalized);
             }
         } else {
             // use backward bitvectors
             falseNum = condNum;
             for (int i = 0; i < condOffsets.length - 1; ++i) {
                 final int featureIndex = featureIndexes[i];
                 for (int j = condOffsets[i + 1] - 1; j >= condOffsets[i]; --j) {
                     if (modelFeatureValuesNormalized[featureIndex] > thresholds[j]) break;
                     treeBitvectors[treeIds[j]] &= backwardBitVectors[j];
                     --falseNum;
                 }
             }

             for (int i = 0; i < leafOffsets.length - 1; ++i) {
                 final int leafIdx = findIndexOfRightMostBit(treeBitvectors[i]);
                 score += weights[i] * leaves[leafOffsets[i + 1] - 1 - leafIdx].score(modelFeatureValuesNormalized);
             }
         }

         // update false ratio
         falseRatio = falseRatio * falseRatioDecay + (falseNum * 1.0f / condNum) * (1.0f - falseRatioDecay);
         return score;
     }

 }

 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.Query;
 import org.apache.solr.ltr.feature.Feature;
 import org.apache.solr.ltr.feature.FeatureException;
 import org.apache.solr.ltr.norm.IdentityNormalizer;
 import org.apache.solr.ltr.norm.Normalizer;
 import org.apache.solr.request.SolrQueryRequest;
 import org.junit.Ignore;
 import org.junit.Test;

 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Random;

 import static org.hamcrest.CoreMatchers.is;
 import static org.junit.Assert.assertThat;

 public class TestQuickScorerTreesModelBenchmark {

     /**
      * 产生特征
      * @param featureNum 特征个数
      * @return
      */
     private List<Feature> createDummyFeatures(int featureNum) {
         List<Feature> features = new ArrayList<>();
         for (int i = 0; i < featureNum; ++i) {
             features.add(new Feature("fv_" + i, null) {
                 @Override
                 protected void validate() throws FeatureException { }

                 @Override
                 public FeatureWeight createWeight(IndexSearcher searcher, boolean needsScores, SolrQueryRequest request,
                                                   Query originalQuery, Map<String, String[]> efi) throws IOException {
                     return null;
                 }

                 @Override
                 public LinkedHashMap<String, Object> paramsToMap() {
                     return null;
                 }
             });
         }
         return features;
     }

     private List<Normalizer> createDummyNormalizer(int featureNum) {
         List<Normalizer> normalizers = new ArrayList<>();
         for (int i = 0; i < featureNum; ++i) {
             normalizers.add(new IdentityNormalizer());
         }
         return normalizers;
     }

     /**
      * 创建单棵树
      * 递归调用自己
      * @param leafNum 叶子个数
      * @param features 特征
      * @param rand 产生随机数
      * @return
      */
     private Map<String, Object> createRandomTree(int leafNum, List<Feature> features, Random rand) {
         Map<String, Object> node = new HashMap<>();
         if (leafNum == 1) {
             // leaf
             node.put("value", Float.toString(rand.nextFloat() - 0.5f)); // [-0.5, 0.5)
             return node;
         }

         // branch
         node.put("feature", features.get(rand.nextInt(features.size())).getName());
         node.put("threshold", Float.toString(rand.nextFloat() - 0.5f)); // [-0.5, 0.5)
         node.put("left", createRandomTree(leafNum / 2, features, rand));
         node.put("right", createRandomTree(leafNum - leafNum / 2, features, rand));
         return node;
     }

     /**
      *　这里随机创建多棵树作为model测试
      * @param treeNum 树的个数
      * @param leafNum 叶子个数
      * @param features 特征
      * @param rand 产生随机数
      * @return
      */
     private List<Object> createRandomMultipleAdditiveTrees(int treeNum, int leafNum, List<Feature> features,
                                                            Random rand) {
         List<Object> trees = new ArrayList<>();
         for (int i = 0; i < treeNum; ++i) {
             Map<String, Object> tree = new HashMap<>();
             tree.put("weight", Float.toString(rand.nextFloat() - 0.5f)); // [-0.5, 0.5) 设置每棵树的学习率
             tree.put("root", createRandomTree(leafNum, features, rand));
             trees.add(tree);
         }
         return trees;
     }

     /**
      * 对比两个打分模型的分值是否一致
      * @param featureNum 特征个数
      * @param treeNum 树个数
      * @param leafNum 叶子个数
      * @param loopNum 样本个数
      * @throws Exception
      */
     private void compareScore(int featureNum, int treeNum, int leafNum, int loopNum) throws Exception {
         Random rand = new Random(0);

         List<Feature> features = createDummyFeatures(featureNum); //产生特征
         List<Normalizer> norms = createDummyNormalizer(featureNum); //标准化

         for (int i = 0; i < loopNum; ++i) {
             List<Object> trees = createRandomMultipleAdditiveTrees(treeNum, leafNum, features, rand);

             MultipleAdditiveTreesModel matModel = new MultipleAdditiveTreesModel("multipleadditivetrees", features, norms,
                     "dummy", features, null);
             matModel.setTrees(trees);
             matModel.validate();

             QuickScorerTreesModel qstModel = new QuickScorerTreesModel("quickscorertrees", features, norms, "dummy", features,
                     null);
             qstModel.setTrees(trees);//设置提供的树模型
             qstModel.validate();//对提供的树结构进行验证

             float[] featureValues = new float[featureNum];
             for (int j = 0; j < 100; ++j) {
                 for (int k = 0; k < featureNum; ++k) featureValues[k] = rand.nextFloat() - 0.5f; // [-0.5, 0.5)

                 float expected = matModel.score(featureValues);
                 float actual = qstModel.score(featureValues);
                 assertThat(actual, is(expected));
                 //System.out.println("expected: " + expected + " actual: " + actual);
             }
         }
     }

     /**
      * 两个模型是否得分一致
      *
      * @throws Exception thrown if testcase failed to initialize models
      */
     /*@Test
     public void testAccuracy() throws Exception {
         compareScore(25, 200, 32, 100);
         //compareScore(19, 500, 31, 10000);
     }*/

     /**
      * 对比两个打分模型打分的时间消耗
      * @param featureNum 特征个数
      * @param treeNum 树个数
      * @param leafNum 叶子个数
      * @param loopNum 样本个数
      * @throws Exception
      */
     private void compareTime(int featureNum, int treeNum, int leafNum, int loopNum) throws Exception {
         Random rand = new Random(0);

         //随机产生features
         List<Feature> features = createDummyFeatures(featureNum);
         //随机产生normalizer
         List<Normalizer> norms = createDummyNormalizer(featureNum);
         //随机创建trees
         List<Object> trees = createRandomMultipleAdditiveTrees(treeNum, leafNum, features, rand);

         //初始化multiple additive trees model
         MultipleAdditiveTreesModel matModel = new MultipleAdditiveTreesModel("multipleadditivetrees", features, norms,
                 "dummy", features, null);
         matModel.setTrees(trees);
         matModel.validate();

         //初始化quick scorer trees model
         QuickScorerTreesModel qstModel = new QuickScorerTreesModel("quickscorertrees", features, norms, "dummy", features,
                 null);
         qstModel.setTrees(trees);
         qstModel.validate();

         //随机产生样本, loopNum * featureNum
         float[][] featureValues = new float[loopNum][featureNum];
         for (int i = 0; i < loopNum; ++i) {
             for (int k = 0; k < featureNum; ++k) {
                 featureValues[i][k] = rand.nextFloat() * 2.0f - 1.0f; // [-1.0, 1.0)
             }
         }

         long start;
         /*long matOpNsec = 0;
         for (int i = 0; i < loopNum; ++i) {
             start = System.nanoTime();
             matModel.score(featureValues[i]);
             matOpNsec += System.nanoTime() - start;
         }
         long qstOpNsec = 0;
         for (int i = 0; i < loopNum; ++i) {
             start = System.nanoTime();
             qstModel.score(featureValues[i]);
             qstOpNsec += System.nanoTime() - start;
         }
         System.out.println("MultipleAdditiveTreesModel : " + matOpNsec / 1000.0 / loopNum + " usec/op");
         System.out.println("QuickScorerTreesModel      : " + qstOpNsec / 1000.0 / loopNum + " usec/op");*/

         long matOpNsec = 0;
         start = System.currentTimeMillis();
         for(int i = 0; i < loopNum; i++) {
             matModel.score(featureValues[i]);
         }
         matOpNsec = System.currentTimeMillis() - start;

         long qstOpNsec = 0;
         start = System.currentTimeMillis();
         for(int i = 0; i < loopNum; i++) {
             qstModel.score(featureValues[i]);
         }
         qstOpNsec = System.currentTimeMillis() - start;

         System.out.println("MultipleAdditiveTreesModel : " + matOpNsec);

         System.out.println("QuickScorerTreesModel : " + qstOpNsec);

         //assertThat(matOpNsec > qstOpNsec, is(true));
     }

     /**
      * 测试性能
      * @throws Exception thrown if testcase failed to initialize models
      */

     @Test
     public void testPerformance() throws Exception {
         //features,trees,leafs,samples
         compareTime(20, 500, 61, 10000);
     }

 }