Allow JVM-Package to access inplace predict method

include/xgboost/c_api.h

@@ -999,6 +999,33 @@ XGB_DLL int XGBoosterPredict(BoosterHandle handle,
                              bst_ulong *out_len,
                              const float **out_result);
 
+/*!
+ * \brief make prediction based on dmat (deprecated, use `XGBoosterPredictFromDMatrix` instead)
+ * \param handle handle
+ * \param dmat data matrix
+ * \param missing value in the input data which needs to be present as a missing value
+ * \param option_mask bit-mask of options taken in prediction, possible values
+ *          0:normal prediction
+ *          1:output margin instead of transformed value
+ *          2:output leaf index of trees instead of leaf value, note leaf index is unique per tree
+ *          4:output feature contributions to individual predictions
+ * \param ntree_limit limit number of trees used for prediction, this is only valid for boosted trees
+ *    when the parameter is set to 0, we will use all the trees\param out_len used to store length of returning result
+ * \param out_len used to store length of returning result
+ * \param out_result used to set a pointer to array
+ * \return 0 when success, -1 when failure happens
+*/
+XGB_DLL int XGBoosterInplacePredict(BoosterHandle handle,
+                                    const float *data,
+                                    size_t num_rows,
+                                    size_t num_features,
+                                    DMatrixHandle d_matrix_handle,
+                                    float missing,
+                                    int option_mask,
+                                    int ntree_limit,
+                                    const bst_ulong **len,
+                                    const float **out_result);
+
 /*!
  * \brief Make prediction from DMatrix, replacing \ref XGBoosterPredict.
  *

jvm-packages/xgboost4j/src/main/java/ml/dmlc/xgboost4j/java/Booster.java

@@ -316,6 +316,159 @@ private synchronized float[][] predict(DMatrix data,
     return predicts;
   }
 
+  /**
+   * Perform thread-safe prediction. Calls
+   * <code>inplace_predict(data, num_rows, num_features, Float.NaN, false, 0, false, false)</code>.
+   *
+   * @param data           Flattened input matrix of features for prediction
+   * @param num_rows       The number of preditions to make (count of input matrix rows)
+   * @param num_features   The number of features in the model (count of input matrix columns)
+   *
+   * @return predict       Result matrix
+   *
+   * @see #inplace_predict(float[] data, int num_rows, int num_features, float missing,
+   *                       boolean outputMargin, int treeLimit, boolean predLeaf,
+   *                       boolean predContribs)
+   */
+  public float[][] inplace_predict(float[] data,
+                                   int num_rows,
+                                   int num_features) throws XGBoostError {
+    return this.inplace_predict(data, num_rows, num_features,
+                Float.NaN, false, 0, false, false);
+  }
+
+  /**
+   * Perform thread-safe prediction. Calls
+   * <code>inplace_predict(data, num_rows, num_features, missing, false, 0, false, false)</code>.
+   *
+   * @param data           Flattened input matrix of features for prediction
+   * @param num_rows       The number of preditions to make (count of input matrix rows)
+   * @param num_features   The number of features in the model (count of input matrix columns)
+   * @param missing        Value indicating missing element in the <code>data</code> input matrix
+   *
+   * @return predict       Result matrix
+   *
+   * @see #inplace_predict(float[] data, int num_rows, int num_features, float missing,
+   *                       boolean outputMargin, int treeLimit, boolean predLeaf,
+   *                       boolean predContribs)
+   */
+  public float[][] inplace_predict(float[] data,
+                                   int num_rows,
+                                   int num_features,
+                                   float missing) throws XGBoostError {
+    return this.inplace_predict(data, num_rows, num_features,
+                missing, false, 0, false, false);
+  }
+
+  /**
+   * Perform thread-safe prediction. Calls
+   * <code>inplace_predict(data, num_rows, num_features, missing,
+   *                       outputMargin, 0, false, false)</code>.
+   *
+   * @param data           Flattened input matrix of features for prediction
+   * @param num_rows       The number of preditions to make (count of input matrix rows)
+   * @param num_features   The number of features in the model (count of input matrix columns)
+   * @param missing        Value indicating missing element in the <code>data</code> input matrix
+   * @param outputMargin   Whether to only predict margin value instead of transformed prediction
+   *
+   * @return predict       Result matrix
+   *
+   * @see #inplace_predict(float[] data, int num_rows, int num_features, float missing,
+   *                       boolean outputMargin, int treeLimit, boolean predLeaf,
+   *                       boolean predContribs)
+   */
+
+  public float[][] inplace_predict(float[] data,
+                                   int num_rows,
+                                   int num_features,
+                                   float missing,
+                                   boolean outputMargin) throws XGBoostError {
+    return this.inplace_predict(data, num_rows, num_features, missing,
+                       outputMargin, 0, false, false);
+  }
+
+  /**
+   * Perform thread-safe prediction. Calls
+   * <code>inplace_predict(data, num_rows, num_features, missing,
+   *                       outputMargin, treeLimit, false, false)</code>.
+   *
+   * @param data           Flattened input matrix of features for prediction
+   * @param num_rows       The number of preditions to make (count of input matrix rows)
+   * @param num_features   The number of features in the model (count of input matrix columns)
+   * @param missing        Value indicating missing element in the <code>data</code> input matrix
+   * @param outputMargin   Whether to only predict margin value instead of transformed prediction
+   * @param treeLimit      limit number of trees, 0 means all trees.
+   *
+   * @return predict       Result matrix
+   *
+   * @see #inplace_predict(float[] data, int num_rows, int num_features, float missing,
+   *                       boolean outputMargin, int treeLimit, boolean predLeaf,
+   *                       boolean predContribs)
+   */
+  public float[][] inplace_predict(float[] data,
+                                   int num_rows,
+                                   int num_features,
+                                   float missing,
+                                   boolean outputMargin,
+                                   int treeLimit) throws XGBoostError {
+    return this.inplace_predict(data, num_rows, num_features, missing,
+                                outputMargin, treeLimit, false, false);
+  }
+
+  /**
+   * Perform thread-safe prediction.
+   *
+   * @param data           Flattened input matrix of features for prediction
+   * @param num_rows       The number of preditions to make (count of input matrix rows)
+   * @param num_features   The number of features in the model (count of input matrix columns)
+   * @param d_matrix_h     The handle for a dmatrix
+   * @param missing        Value indicating missing element in the <code>data</code> input matrix
+   * @param outputMargin   Whether to only predict margin value instead of transformed prediction
+   * @param treeLimit      limit number of trees, 0 means all trees.
+   * @param predLeaf       prediction minimum to keep leafs
+   * @param predContribs   prediction feature contributions
+   *
+   * @return predict       Result matrix
+   */
+  public float[][] inplace_predict(float[] data,
+                                   int num_rows,
+                                   int num_features,
+                                   float missing,
+                                   boolean outputMargin,
+                                   int treeLimit,
+                                   boolean predLeaf,
+                                   boolean predContribs) throws XGBoostError {
+    int optionMask = 0;
+    if (outputMargin) {
+      optionMask = 1;
+    }
+    if (predLeaf) {
+      optionMask = 2;
+    }
+    if (predContribs) {
+      optionMask = 4;
+    }
+    DMatrix d_mat = new DMatrix(data, num_rows, num_features, missing);
+    float[][] rawPredicts = new float[1][];
+    XGBoostJNI.checkCall(XGBoostJNI.XGBoosterInplacePredict(handle, data, num_rows, num_features,
+        d_mat.getHandle(), missing,
+        optionMask, treeLimit, rawPredicts));  // pass missing and treelimit here?
+
+    // System.out.println("Booster.inplace_predict rawPredicts[0].length = " +
+    //    rawPredicts[0].length);
+
+    int row = num_rows;
+    int col = rawPredicts[0].length / row;
+    float[][] predicts = new float[row][col];
+    int r, c;
+    for (int i = 0; i < rawPredicts[0].length; i++) {
+      r = i / col;
+      c = i % col;
+      predicts[r][c] = rawPredicts[0][i];
+    }
+    return predicts;
+  }
+
   /**
    * Predict leaf indices given the data
    *

jvm-packages/xgboost4j/src/main/java/ml/dmlc/xgboost4j/java/XGBoostJNI.java

@@ -119,6 +119,10 @@ public final static native int XGBoosterEvalOneIter(long handle, int iter, long[
   public final static native int XGBoosterPredict(long handle, long dmat, int option_mask,
                                                   int ntree_limit, float[][] predicts);
 
+  public final static native int XGBoosterInplacePredict(long handle, float[] data, int num_rows, int num_features, long d_matrix_handle,
+                                                         float missing, int option_mask, int ntree_limit,
+                                                         float[][] predicts);
+
   public final static native int XGBoosterLoadModel(long handle, String fname);
 
   public final static native int XGBoosterSaveModel(long handle, String fname);

jvm-packages/xgboost4j/src/native/xgboost4j.cpp

@@ -661,6 +661,32 @@ JNIEXPORT jint JNICALL Java_ml_dmlc_xgboost4j_java_XGBoostJNI_XGBoosterPredict
   return ret;
 }
 
+/*
+ * Class:     ml_dmlc_xgboost4j_java_XGBoostJNI
+ * Method:    XGBoosterInplacePredict
+ * Signature: (J[FIII[[F)I
+ */
+JNIEXPORT jint JNICALL Java_ml_dmlc_xgboost4j_java_XGBoostJNI_XGBoosterInplacePredict
+  (JNIEnv *jenv, jclass jcls, jlong jhandle, jfloatArray jdata, jint num_rows, jint num_features, jlong d_matrix_handle,
+                                             jfloat missing, jint option_mask, jint treeLimit, jobjectArray jout) {
+  BoosterHandle handle = (BoosterHandle) jhandle;
+  DMatrixHandle dmat = (DMatrixHandle) d_matrix_handle;
+  jfloat* data = jenv->GetFloatArrayElements(jdata, 0);
+  const bst_ulong *len;
+  float *result;
+  int ret = XGBoosterInplacePredict(handle, data, num_rows, num_features, dmat, missing, option_mask, treeLimit,
+            &len, (const float **) &result);
+  JVM_CHECK_CALL(ret);
+  jenv->ReleaseFloatArrayElements(jdata, data, 0);
+  if (*len) {
+    jsize jlen = (jsize) *len;
+    jfloatArray jarray = jenv->NewFloatArray(jlen);
+    jenv->SetFloatArrayRegion(jarray, 0, jlen, (jfloat *) result);
+    jenv->SetObjectArrayElement(jout, 0, jarray);
+  }
+  return ret;
+}
+
 /*
  * Class:     ml_dmlc_xgboost4j_java_XGBoostJNI
  * Method:    XGBoosterLoadModel