8

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

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

谢谢你的帮助！

4

3 回答 3

13

我花了一些时间在我自己的问题上，并想分享我的答案，因为我觉得在stackoverflow上没有太多关于这个主题的信息。我还认为，由于 Java 的性能和其他良好的软件开发特性的提高，Java 将在科学计算中变得更加相关（例如，参见 WEKA 数据挖掘包）。

总的来说，事实证明，使用正确的工具使用 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 ，然后在第 48 行通过提供 JDK 路径来修改setup.py脚本：

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 还是服务器 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()

从 Java 调用 Java 类也使用 Numpy

让我们开始实现一个 Java 类，其中包含一些我想应用于numpy arrays的函数。由于没有状态的概念，我使用静态函数，这样我就不需要创建任何 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 向量乘以标量（方法multiply），最后是矩阵乘法（方法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()
于 2012-06-03T18:27:45.090 回答
2

我认为 Jython 是最好的选择之一——这使得在 python 中使用 java 对象变得无缝。我实际上将 weka 与我的 python 程序集成在一起，而且非常简单。只需导入 weka 类并像在 python 代码中的 java 中那样调用它们。

http://www.jython.org/

于 2012-09-13T20:01:59.703 回答
1

我不确定 numpy 支持，但以下可能会有所帮助：

http://pypi.python.org/pypi/JCC/

于 2012-05-22T18:24:44.910 回答