如何从python/numpy调用java函数？

Question

我很清楚如何使用C++扩展Python,但是如果我想在Java中编写一个与numpy一起使用的函数呢？

这是一个简单的场景:我想使用Java类计算numpy数组的平均值.如何将numpy向量传递给Java类并收集结果？

谢谢你的帮助!

Answer 1

我花了一些时间在我自己的问题上,并希望分享我的答案,因为我觉得在stackoverflow上关于这个主题的信息不多.我还认为Java将在科学计算中变得更加相关(例如,参见用于数据挖掘的WEKA包),因为Java的性能和其他良好的软件开发功能得到了改进.

一般来说,使用正确的工具,使用Java扩展Python比使用C/C++更容易!

概述和评估从Python调用Java的工具

• http://pypi.python.org/pypi/JCC:由于没有适当的文档,这个工具没用.

• Py4J:需要在使用python之前启动Java进程.正如其他人所说,这是一个可能的失败点.此外,没有记录很多使用的例子.

• JPype:虽然开发似乎是死亡,但它运作良好,网上有很多例子(例如参见http://kogs-www.informatik.uni-hamburg.de/~meine/weka-python/使用用Java编写的数据挖掘库).因此我决定专注于这个工具.

在Fedora 16上安装JPype

我正在使用Fedora 16,因为在Linux上安装JPype时存在一些问题,我描述了我的方法.下载JPype,然后通过提供JDK路径修改setup.py脚本,在第48行:

self.javaHome = '/usr/java/default'

然后运行:

sudo python setup.py install

安装成功后,请检查此文件:

/usr/lib64/python2.7/site-packages/jpype/_linux.py

并将方法getDefaultJVMPath()删除或重命名为getDefaultJVMPath_old(),然后添加以下方法:

def getDefaultJVMPath():
    return "/usr/java/default/jre/lib/amd64/server/libjvm.so"

替代方法:不要在上面的文件_linux.py中进行任何更改,但绝不使用方法getDefaultJVMPath()(或调用此方法的方法).在使用getDefaultJVMPath()的地方直接提供JVM的路径.请注意,有几个路径,例如在我的系统中,我也有以下路径,指的是不同版本的JVM(我不清楚客户端或服务器JVM是否更适合):

• /usr/lib/jvm/java-1.5.0-gcj-1.5.0.0/jre/lib/x86_64/client/libjvm.so
• /usr/lib/jvm/java-1.5.0-gcj-1.5.0.0/jre/lib/x86_64/server/libjvm.so
• /usr/lib/jvm/java-1.6.0-openjdk-1.6.0.0.x86_64/jre/lib/amd64/server/libjvm.so

最后,将以下行添加到〜/ .bashrc(或在每次打开python解释器之前运行它):

export JAVA_HOME='/usr/java/default'

(上面的目录实际上只是我上一版JDK的符号链接,它位于/usr/java/jdk1.7.0_04).

请注意,已下载JPype的目录中的所有测试,即JPype-0.5.4.2/test/testsuite.py都将失败(因此不关心它们).

要查看它是否有效,请在python中测试此脚本:

import jpype 
jvmPath = jpype.getDefaultJVMPath() 
jpype.startJVM(jvmPath)
# print a random text using a Java class
jpype.java.lang.System.out.println ('Berlusconi likes women') 
jpype.shutdownJVM() 

使用Numpy从Java调用Java类

让我们开始实现一个包含一些我想要应用于numpy数组的函数的Java类.由于没有状态概念,我使用静态函数,因此我不需要创建任何Java对象(创建Java对象不会改变任何东西).

/**
 * Cookbook to pass numpy arrays to Java via Jpype
 * @author Mannaggia
 */

package test.java;

public class Average2 {

public static double compute_average(double[] the_array){
    // compute the average
    double result=0;
    int i;
    for (i=0;i<the_array.length;i++){
        result=result+the_array[i];
    }
    return result/the_array.length;
}
// multiplies array by a scalar
public static double[] multiply(double[] the_array, double factor) {

    int i;
    double[] the_result= new double[the_array.length];
    for (i=0;i<the_array.length;i++) {
        the_result[i]=the_array[i]*factor;
    }
    return the_result;
}

/**
 * Matrix multiplication. 
 */
public static double[][] mult_mat(double[][] mat1, double[][] mat2){
    // find sizes
    int n1=mat1.length;
    int n2=mat2.length;
    int m1=mat1[0].length;
    int m2=mat2[0].length;
    // check that we can multiply
    if (n2 !=m1) {
        //System.err.println("Error: The number of columns of the first argument must equal the number of rows of the second");
        //return null;
        throw new IllegalArgumentException("Error: The number of columns of the first argument must equal the number of rows of the second");
    }
    // if we can, then multiply
    double[][] the_results=new double[n1][m2];
    int i,j,k;
    for (i=0;i<n1;i++){
        for (j=0;j<m2;j++){
            // initialize
            the_results[i][j]=0;
            for (k=0;k<m1;k++) {
                the_results[i][j]=the_results[i][j]+mat1[i][k]*mat2[k][j];
            }
        }
    }
    return the_results;
}

/**
 * @param args
 */
public static void main(String[] args) {
    // test case
    double an_array[]={1.0, 2.0,3.0,4.0};
    double res=Average2.compute_average(an_array);
    System.out.println("Average is =" + res);
}
}

类的名称有点误导,因为我们不仅要计算numpy向量的平均值(使用方法compute_average),还要将numpy向量乘以标量(方法乘法),最后,矩阵乘法(方法mult_mat).

编译完上面的Java类之后,我们现在可以运行以下Python脚本:

import numpy as np
import jpype

jvmPath = jpype.getDefaultJVMPath() 
# we to specify the classpath used by the JVM
classpath='/home/mannaggia/workspace/TestJava/bin'
jpype.startJVM(jvmPath,'-Djava.class.path=%s' % classpath)

# numpy array
the_array=np.array([1.1, 2.3, 4, 6,7])
# build a JArray, not that we need to specify the Java double type using the jpype.JDouble wrapper
the_jarray2=jpype.JArray(jpype.JDouble, the_array.ndim)(the_array.tolist())
Class_average2=testPkg.Average2 
res2=Class_average2.compute_average(the_jarray2)
np.abs(np.average(the_array)-res2) # ok perfect match! 

# now try to multiply an array
res3=Class_average2.multiply(the_jarray2,jpype.JDouble(3))
# convert to numpy array
res4=np.array(res3) #ok

# matrix multiplication
the_mat1=np.array([[1,2,3], [4,5,6], [7,8,9]],dtype=float)
#the_mat2=np.array([[1,0,0], [0,1,0], [0,0,1]],dtype=float)
the_mat2=np.array([[1], [1], [1]],dtype=float)
the_mat3=np.array([[1, 2, 3]],dtype=float)

the_jmat1=jpype.JArray(jpype.JDouble, the_mat1.ndim)(the_mat1.tolist())
the_jmat2=jpype.JArray(jpype.JDouble, the_mat2.ndim)(the_mat2.tolist())
res5=Class_average2.mult_mat(the_jmat1,the_jmat2)
res6=np.array(res5) #ok

# other test
the_jmat3=jpype.JArray(jpype.JDouble, the_mat3.ndim)(the_mat3.tolist())
res7=Class_average2.mult_mat(the_jmat3,the_jmat2)
res8=np.array(res7)
res9=Class_average2.mult_mat(the_jmat2,the_jmat3)
res10=np.array(res9)

# test error due to invalid matrix multiplication
the_mat4=np.array([[1], [2]],dtype=float)
the_jmat4=jpype.JArray(jpype.JDouble, the_mat4.ndim)(the_mat4.tolist())
res11=Class_average2.mult_mat(the_jmat1,the_jmat4)

jpype.java.lang.System.out.println ('Goodbye!') 
jpype.shutdownJVM()