Added percentile implementation for Pytorch engine

Author: feklin.v.v

engines/pytorch/pytorch-engine/src/main/java/ai/djl/pytorch/engine/PtNDArray.java

@@ -1547,13 +1547,17 @@ public PtNDArray argMin(int axis) {
     /** {@inheritDoc} */
     @Override
     public PtNDArray percentile(Number percentile) {
-        throw new UnsupportedOperationException("Not implemented");
+        return percentile(percentile, new int[] {-1});
     }
 
     /** {@inheritDoc} */
     @Override
     public PtNDArray percentile(Number percentile, int[] axes) {
-        throw new UnsupportedOperationException("Not implemented");
+        if (axes.length != 1) {
+            throw new UnsupportedOperationException(
+                    "Not supporting zero or multi-dimension percentile");
+        }
+        return JniUtils.percentile(this, percentile, axes[0], false);
     }
 
     /** {@inheritDoc} */

engines/pytorch/pytorch-engine/src/main/java/ai/djl/pytorch/jni/JniUtils.java

@@ -888,6 +888,14 @@ public static NDList median(PtNDArray ndArray, long dim, boolean keepDim) {
                 new PtNDArray(ndArray.getManager(), handles[1]));
     }
 
+    public static PtNDArray percentile(
+            PtNDArray ndArray, Number percentile, long dim, boolean keepDim) {
+        float quantile = percentile.floatValue() / 100;
+        return new PtNDArray(
+                ndArray.getManager(),
+                PyTorchLibrary.LIB.torchQuantile(ndArray.getHandle(), quantile, dim, keepDim));
+    }
+
     public static PtNDArray mean(PtNDArray ndArray) {
         return new PtNDArray(
                 ndArray.getManager(), PyTorchLibrary.LIB.torchMean(ndArray.getHandle()));

engines/pytorch/pytorch-engine/src/main/java/ai/djl/pytorch/jni/PyTorchLibrary.java

@@ -248,6 +248,8 @@ native void torchIndexPut(
 
     native long[] torchMedian(long self, long dim, boolean keepDim);
 
+    native long torchQuantile(long self, float quantile, long dim, boolean keepDim);
+
     native long torchMin(long handle);
 
     native long torchMin(long handle, long dim, boolean keepDim);

engines/pytorch/pytorch-native/src/main/native/ai_djl_pytorch_jni_PyTorchLibrary_torch_pointwise.cc

@@ -227,6 +227,15 @@ JNIEXPORT jlongArray JNICALL Java_ai_djl_pytorch_jni_PyTorchLibrary_torchMedian(
   API_END_RETURN()
 }
 
+JNIEXPORT jlong JNICALL Java_ai_djl_pytorch_jni_PyTorchLibrary_torchQuantile(
+    JNIEnv* env, jobject jthis, jlong jself, jfloat q, jlong jdim, jboolean keep_dim) {
+  API_BEGIN()
+  const auto* self_ptr = reinterpret_cast<torch::Tensor*>(jself);
+  const auto* result_ptr = new torch::Tensor(torch::quantile(*self_ptr, q, jdim, keep_dim));
+  return reinterpret_cast<uintptr_t>(result_ptr);
+  API_END_RETURN()
+}
+
 JNIEXPORT jlong JNICALL Java_ai_djl_pytorch_jni_PyTorchLibrary_torchAbs(JNIEnv* env, jobject jthis, jlong jhandle) {
   API_BEGIN()
   const auto* tensor_ptr = reinterpret_cast<torch::Tensor*>(jhandle);

integration/src/main/java/ai/djl/integration/tests/ndarray/NDArrayElementComparisonOpTest.java

@@ -611,6 +611,38 @@ public void testMedian() {
         }
     }
 
+    @Test
+    public void testPercentile() {
+        try (NDManager manager = NDManager.newBaseManager(TestUtils.getEngine())) {
+            NDArray array1 = manager.create(new float[] {1, 3, 2, 5, 4});
+            Assert.assertEquals(array1.percentile(10), manager.create(1.4f));
+            Assert.assertEquals(array1.percentile(90), manager.create(4.6f));
+
+            NDArray array2 =
+                    manager.create(
+                            new float[][] {
+                                {11, 12, 13, 14, 15},
+                                {21, 22, 23, 24, 25},
+                                {31, 32, 33, 34, 35},
+                                {41, 42, 43, 44, 45},
+                                {51, 52, 53, 54, 55}
+                            });
+            Assert.assertEquals(
+                    array2.percentile(10, new int[] {1}),
+                    manager.create(new float[] {11.4f, 21.4f, 31.4f, 41.4f, 51.4f}));
+            Assert.assertEquals(
+                    array2.percentile(90, new int[] {1}),
+                    manager.create(new float[] {14.6f, 24.6f, 34.6f, 44.6f, 54.6f}));
+
+            Assert.assertEquals(
+                    array2.percentile(10, new int[] {0}),
+                    manager.create(new float[] {15, 16, 17, 18, 19}));
+            Assert.assertEquals(
+                    array2.percentile(90, new int[] {0}),
+                    manager.create(new float[] {47, 48, 49, 50, 51}));
+        }
+    }
+
     @Test
     public void testWhere() {
         try (NDManager manager = NDManager.newBaseManager(TestUtils.getEngine())) {