JNI Kernel Extension for SVM^light

Overview of this Software

This software is an extension of the SVMlight software (V6.01) available at http://svmlight.joachims.org/. It provides an interface to kernel functions that are implemented in Java by means of the Java Native Interface (JNI) Invocation API. Technically, the custom C/C++ kernel module of SVMlight now becomes a proxy that is tightly coupled to the Java class edu.unika.aifb.jnikernel.KernelManager. This class delegates all kernel evaluation calls to a user-specified Java class that implements the edu.unika.aifb.kernels.api.Kernel interface. Thus, SVMlight can directly (i.e. without further modifications) work with any Java class that implements this interface. A small disclaimer: To stick to the modular setup of SVMlight, all operations for converting C/C++ datatypes to Java and back are happening within the kernel interface and, as such, again and again during each kernel evaluation. Especially when dealing with large vectors, the repeated conversion to Java will result in a substantial computational overhead. For smaller vectors or for kernels defined on the custom String field of the SVMlight instances the conversion overhead is, however, neglectable.

News

• 2007-07-04, version 1.2 released; changes are:
  • fixed (another) a bug with jnikernel.normalize option (occured only in conjunction with svm_classify, not with svm_learn)
• 2007-05-29, version 1.1 released; changes are:
  • fixed a bug with jnikernel.normalize option
  • more informative error messages ;-)
• 2007-05-25, version 1.0 released; changes are:
  • switched optional constructor argument for kernel implementations from java.lang.String (i.e. parameter file path) to java.util.Properties (carrying key-value pairs for the parameters)
  • moved kernel interface to edu.unika.aifb.kernels.api.Kernel
  • introduced jnikernel.normalize option (see below)
  • minor bug fixes
• 2007-01-19, version 0.9 released

Download and Installation

1. You can download precompiled versions of SVM^light that incorporate the extension. Precompiled versions are available as follows:
   • for Windows: svmlight-jnikernel-win32.tar.gz, compiled with cygwin/mingw gcc on a Intel 32bit WinXP system
   • for Linux: svmlight-jnikernel-linux32.tar.gz, compiled on an Intel 32bit Debian Sarge system
2. Download the corresponding Java package: jnikernel.jar (corresponding Java documentation: jnikernel-javadoc.tar.gz, can also be viewed online here).
3. You need to have the Sun Java Runtime Environment installed. Both versions have been linked to work with the Sun JDK/JRE 1.5 shared libraries (should also work with Java 1.6). Basically, this means that you have to make sure that the Sun JVM shared libraries are available to SVMlight (c.f. Sun JNI Guide, ch 7.2.1).
   • On Windows systems, this typically means that the directory of jvm.dll needs to be included in the PATH environment variable.
   • On Linux systems, libjvm.so needs to be symlinked into /lib or its directory needs to be included in the LD_LIBRARY_PATH environment variable.
4. Go and test your installation (see below). If it does not work, you might need to compile the whole thing on your system.

Compiling SVM^light with the JNI Kernel Extension

1. Get the SVM^light sources (V6.01) from http://download.joachims.org/svm_light/current/svm_light.tar.gz.
2. Download the kernel modules in kernel.c and and kernel.h and place them inside the base folder of the SVMlight sources.
3. Place the include "svm_common.h" statement in scm_classify.c inside an extern "C" {...} statement.
4. Place the include "svm_common.h" and include "svm_learn.h" statements in scm_learn_main.c inside an extern "C" {...} statement.
5. You need to compile the new kernel module using C++, the core SVM^light modules using plain C and link everything into executables using a C++ linker. Further, you must instruct the compiler/linker to use the respective JNI include files and libraries. For Sun Java 1.2 and above (c.f. Sun JNI Guide, ch 7.2.1), this means:
   • instruct the compiler to use the include files that can be found in the include subdirectorie(s) of your JDK installation (e.g. C:\Program Files\Java\jdk1.5.0\include and C:\Program Files\Java\jdk1.5.0\include\win32 on Windows)
   • instruct the linker to use the libraries jvm.lib for Windows (typically in C:\Program Files\Java\jdk1.5.0\lib) or libjvm.so for Linux.
   To save you breath and time, you may download an adapted SVM^light makefile (just change the respective JDK/JRE directories) here: Makefile.

Usage

• From within SVM^light, the custom kernel module can be called by using the "-t 4" and "-u parameterfile" option parameters.
• The specified parameter file contains all relevant settings for (i) the JNI interface and (ii) the implementing Java classes. It contains key-value pairs in the following format (largely consistent with the Java Properties file format, but with key-value delimiters restricted to whitespaces)
  #<comment>
<key><whitespace><value>
<key><whitepsace><value>
...
  A typical parameter file will look like this:
  #JNI kernel extension parameter
jnikernel.class edu.unika.aifb.kernels.examples.Linear
#JNIparameters
jvm.option -Xmx256M
jvm.option -Djava.class.path=./jnikernel.jar
#other parameters (for the implementation)
#...
• The jnikernel.class parameter is mandatory and needs to be set to the Java class that implements the desired kernel.
• Multiple jvm.option parameters may be set, which determine the Java Virtual Machine environment. The parameter values should be in standard JNI format (roughly corresponding to the Java command line parameters), c.f. the Sun JNI Guide, ch 7.1. The most important one will usually be the parameter for setting the classpath, as the JVM will need to find jnikernel.jar and any further Java libraries needed to run the kernel implementations.
• A further parameter, jnikernel.normalize has been introduced in version 1.0 - it acts as a switch (i.e. it is "on" if present, "off" otherwise - regardless of specified values) and results in a cosine normalization of the embedded kernel.
• The file may contain further parameters which the JNI kernel extension tries to pass to the backend kernel constructor during initialization (see below).
• You can test your installation as follows. Get some simple test data set, e.g. the example data from the SVM^light website at http://download.joachims.org/svm_light/examples/example1.tar.gz and try it with the linear kernel of SVM^light ("-t 0" option). Then try to use the above configuration which will use an example implementation of the linear kernel in Java (included in jnikernel.jar). Results should be the same except for a somewhat slower running time. Congrats, your installation is ready!

Implementing Own Kernels

You can implement whatever kernel, just make sure that it implements the edu.unika.aifb.kernels.api.Kernel interface (check the corresponding JavaDoc for details: jnikernel-javadoc.tar.gz or online here). If parameters need to be passed to the kernel implementation, this can be done by implementing a constructor that takes a single java.util.Properties argument. The extension is implemented in such a way that during initialization, the KernelManager will check whether the implementing kernel class has a matching constructor. If so, it will pass the contents of the parameter file such that other, implementation-specific parameters can be read. If not, the default constructor will be used.

License and Acknowledgements

This extension can be freely used and modified but work based on this implementation should acknowledge this source by pointing to this website. When using the extension, please make sure that you comply with the (separate) license of the basic SVM^light software.

Contact

For any questions, please contact Stephan Bloehdorn. You might also like to have a look at the Semantic Kernel Extension for SVM^light available here.