├── nbproject ├── private │ ├── config.properties │ ├── private.properties │ └── private.xml ├── genfiles.properties ├── project.xml ├── project.properties └── build-impl.xml ├── dist └── libsvm-java.jar ├── manifest.mf ├── demo.sh ├── src ├── ca │ └── uwo │ │ └── csd │ │ └── ai │ │ └── nlp │ │ ├── libsvm │ │ ├── svm_print_interface.java │ │ ├── svm_node.java │ │ ├── svm_problem.java │ │ ├── ex │ │ │ ├── Instance.java │ │ │ ├── SVMPredictor.java │ │ │ └── SVMTrainer.java │ │ ├── svm_model.java │ │ └── svm_parameter.java │ │ ├── kernel │ │ ├── CustomKernel.java │ │ ├── KernelManager.java │ │ ├── CompositeKernel.java │ │ ├── LinearKernel.java │ │ ├── RBFKernel.java │ │ └── TreeKernel.java │ │ └── common │ │ ├── Tree.java │ │ └── SparseVector.java ├── utils │ └── DataFileReader.java ├── Demo.java └── svm_scale.java ├── check.sh ├── README.md ├── COPYRIGHT ├── COPYRIGHT.libsvm └── README.libsvm /nbproject/private/config.properties: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /dist/libsvm-java.jar: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/syeedibnfaiz/libsvm-java-kernel/HEAD/dist/libsvm-java.jar -------------------------------------------------------------------------------- /manifest.mf: -------------------------------------------------------------------------------- 1 | Manifest-Version: 1.0 2 | X-COMMENT: Main-Class will be added automatically by build 3 | 4 | -------------------------------------------------------------------------------- /demo.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | #build 3 | ant 4 | java -cp dist/libsvm-java.jar Demo a1a.train a1a.test a1a.out 5 | 6 | -------------------------------------------------------------------------------- /src/ca/uwo/csd/ai/nlp/libsvm/svm_print_interface.java: -------------------------------------------------------------------------------- 1 | package ca.uwo.csd.ai.nlp.libsvm; 2 | 3 | public interface svm_print_interface { 4 | 5 | public void print(String s); 6 | } 7 | -------------------------------------------------------------------------------- /nbproject/private/private.properties: -------------------------------------------------------------------------------- 1 | compile.on.save=true 2 | do.depend=false 3 | do.jar=true 4 | javac.debug=true 5 | javadoc.preview=true 6 | user.properties.file=C:\\Users\\tonatuni\\.netbeans\\7.0\\build.properties 7 | -------------------------------------------------------------------------------- /nbproject/private/private.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | -------------------------------------------------------------------------------- /src/ca/uwo/csd/ai/nlp/libsvm/svm_node.java: -------------------------------------------------------------------------------- 1 | package ca.uwo.csd.ai.nlp.libsvm; 2 | 3 | public class svm_node implements java.io.Serializable { 4 | 5 | public Object data; 6 | 7 | public svm_node() { 8 | } 9 | 10 | public svm_node(Object data) { 11 | this.data = data; 12 | } 13 | } 14 | -------------------------------------------------------------------------------- /src/ca/uwo/csd/ai/nlp/kernel/CustomKernel.java: -------------------------------------------------------------------------------- 1 | package ca.uwo.csd.ai.nlp.kernel; 2 | 3 | import ca.uwo.csd.ai.nlp.libsvm.svm_node; 4 | 5 | /** 6 | * Interface for a custom kernel function 7 | * @author Syeed Ibn Faiz 8 | */ 9 | public interface CustomKernel { 10 | double evaluate(svm_node x, svm_node y); 11 | } 12 | -------------------------------------------------------------------------------- /src/ca/uwo/csd/ai/nlp/libsvm/svm_problem.java: -------------------------------------------------------------------------------- 1 | package ca.uwo.csd.ai.nlp.libsvm; 2 | 3 | public class svm_problem implements java.io.Serializable { 4 | 5 | public int l; 6 | public double[] y; 7 | public svm_node[] x; 8 | 9 | public svm_problem(int l, double[] y, svm_node[] x) { 10 | this.l = l; 11 | this.y = y; 12 | this.x = x; 13 | } 14 | 15 | public svm_problem() { 16 | } 17 | 18 | } 19 | -------------------------------------------------------------------------------- /nbproject/genfiles.properties: -------------------------------------------------------------------------------- 1 | build.xml.data.CRC32=1390663b 2 | build.xml.script.CRC32=b6f8644c 3 | build.xml.stylesheet.CRC32=28e38971@1.44.1.45 4 | # This file is used by a NetBeans-based IDE to track changes in generated files such as build-impl.xml. 5 | # Do not edit this file. You may delete it but then the IDE will never regenerate such files for you. 6 | nbproject/build-impl.xml.data.CRC32=1390663b 7 | nbproject/build-impl.xml.script.CRC32=3a4ce78d 8 | nbproject/build-impl.xml.stylesheet.CRC32=0ae3a408@1.44.1.45 9 | -------------------------------------------------------------------------------- /nbproject/project.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | org.netbeans.modules.java.j2seproject 4 | 5 | 6 | libsvm-java 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | -------------------------------------------------------------------------------- /src/ca/uwo/csd/ai/nlp/kernel/KernelManager.java: -------------------------------------------------------------------------------- 1 | package ca.uwo.csd.ai.nlp.kernel; 2 | 3 | /** 4 | * KernelManager provides the custom kernel function to svm. 5 | * @author Syeed Ibn Faiz 6 | */ 7 | public class KernelManager { 8 | static private CustomKernel customKernel; 9 | 10 | public static CustomKernel getCustomKernel() { 11 | return customKernel; 12 | } 13 | 14 | /** 15 | * Registers the custom kernel 16 | * @param customKernel 17 | */ 18 | public static void setCustomKernel(CustomKernel customKernel) { 19 | KernelManager.customKernel = customKernel; 20 | } 21 | 22 | } 23 | -------------------------------------------------------------------------------- /src/ca/uwo/csd/ai/nlp/libsvm/ex/Instance.java: -------------------------------------------------------------------------------- 1 | package ca.uwo.csd.ai.nlp.libsvm.ex; 2 | 3 | /** 4 | * 5 | * @author Syeed Ibn Faiz 6 | */ 7 | public class Instance { 8 | private double label; 9 | private Object data; 10 | 11 | public Instance(double label, Object data) { 12 | this.label = label; 13 | this.data = data; 14 | } 15 | 16 | public Object getData() { 17 | return data; 18 | } 19 | 20 | public void setData(Object data) { 21 | this.data = data; 22 | } 23 | 24 | public double getLabel() { 25 | return label; 26 | } 27 | 28 | public void setLabel(double label) { 29 | this.label = label; 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /check.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | #This script checks the integrity of the library 3 | #The output produced by the library is matched against 4 | #that produced by the original tool 5 | 6 | #generate output 7 | #note that the Demo uses the linear kernel 8 | java -cp dist/libsvm-java.jar Demo a1a.train a1a.test a1a.out 9 | 10 | #download libsvm 11 | wget http://www.csie.ntu.edu.tw/~cjlin/cgi-bin/libsvm.cgi?+http://www.csie.ntu.edu.tw/~cjlin/libsvm+tar.gz 12 | mv libsvm* libsvm.tar.gz 13 | tar xzf libsvm.tar.gz 14 | rm libsvm.tar.gz 15 | cd libsvm* 16 | make 17 | #generate output using the linear kernel 18 | ./svm-train -t 0 ../a1a.train a1a.train.model 19 | ./svm-predict ../a1a.test a1a.train.model a1a.out 20 | cd .. 21 | diff -w a1a.out ./libsvm*/a1a.out 22 | 23 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | Refactored LibSVM in Java making it easy to plug in a custom kernel. 2 | 3 | Use demo.sh to run the demo program. 4 | To learn how you can use the library see src/Demo.java. 5 | 6 | To write a kernel all you have to do is to implement kernel.CustomKernel and 7 | then register your kernel with the kernel.KernelManager. 8 | 9 | For example, the following code snippet registers an anonymous custom kernel: 10 | KernelManager.setCustomKernel(new CustomKernel() { 11 | @Override 12 | public double evaluate(svm_node x, svm_node y) { 13 | //do something fancy 14 | return 0.3141592654; 15 | } 16 | }); 17 | 18 | 19 | Syeed Ibn Faiz 20 | University of Western Ontario 21 | syeedibnfaiz@gmail.com 22 | -------------------------------------------------------------------------------- /src/ca/uwo/csd/ai/nlp/kernel/CompositeKernel.java: -------------------------------------------------------------------------------- 1 | package ca.uwo.csd.ai.nlp.kernel; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | import ca.uwo.csd.ai.nlp.libsvm.svm_node; 6 | 7 | /** 8 | * 9 | * @author Syeed Ibn Faiz 10 | */ 11 | public class CompositeKernel implements CustomKernel { 12 | private List kernels; 13 | 14 | public CompositeKernel() { 15 | this(new ArrayList()); 16 | } 17 | 18 | public CompositeKernel(List kernels) { 19 | this.kernels = kernels; 20 | } 21 | 22 | @Override 23 | public double evaluate(svm_node x, svm_node y) { 24 | double value = 0.0; 25 | for (CustomKernel kernel : kernels) { 26 | value += kernel.evaluate(x, y); 27 | } 28 | return value; 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /src/ca/uwo/csd/ai/nlp/common/Tree.java: -------------------------------------------------------------------------------- 1 | package ca.uwo.csd.ai.nlp.common; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | /** 7 | * Dummy Tree data structure 8 | * @author Syeed Ibn Faiz 9 | */ 10 | public class Tree { 11 | private String value; 12 | private List children; 13 | 14 | public Tree(String value) { 15 | this.value = value; 16 | children = new ArrayList(); 17 | } 18 | 19 | public Tree(String value, List children) { 20 | this.value = value; 21 | this.children = children; 22 | } 23 | 24 | public List getChildrenAsList() { 25 | return children; 26 | } 27 | 28 | public String value() { 29 | return value; 30 | } 31 | 32 | public boolean isLeaf() { 33 | return children.isEmpty(); 34 | } 35 | } 36 | -------------------------------------------------------------------------------- /src/ca/uwo/csd/ai/nlp/kernel/LinearKernel.java: -------------------------------------------------------------------------------- 1 | package ca.uwo.csd.ai.nlp.kernel; 2 | 3 | import ca.uwo.csd.ai.nlp.common.SparseVector; 4 | import ca.uwo.csd.ai.nlp.libsvm.svm_node; 5 | import java.io.Serializable; 6 | 7 | /** 8 | * LinearKernel implements a linear kernel function. 9 | * @author Syeed Ibn Faiz 10 | */ 11 | public class LinearKernel implements CustomKernel, Serializable { 12 | 13 | @Override 14 | public double evaluate(svm_node x, svm_node y) { 15 | if (!(x.data instanceof SparseVector) || !(y.data instanceof SparseVector)) { 16 | throw new RuntimeException("Could not find sparse vectors in svm_nodes"); 17 | } 18 | SparseVector v1 = (SparseVector) x.data; 19 | SparseVector v2 = (SparseVector) y.data; 20 | 21 | return v1.dot(v2); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /src/ca/uwo/csd/ai/nlp/libsvm/svm_model.java: -------------------------------------------------------------------------------- 1 | // 2 | // svm_model 3 | // 4 | package ca.uwo.csd.ai.nlp.libsvm; 5 | 6 | public class svm_model implements java.io.Serializable { 7 | 8 | public svm_parameter param; // parameter 9 | public int nr_class; // number of classes, = 2 in regression/one class svm 10 | public int l; // total #SV 11 | public svm_node[] SV; // SVs (SV[l]) 12 | public double[][] sv_coef; // coefficients for SVs in decision functions (sv_coef[k-1][l]) 13 | public double[] rho; // constants in decision functions (rho[k*(k-1)/2]) 14 | public double[] probA; // pariwise probability information 15 | public double[] probB; 16 | // for classification only 17 | public int[] label; // label of each class (label[k]) 18 | public int[] nSV; // number of SVs for each class (nSV[k]) 19 | // nSV[0] + nSV[1] + ... + nSV[k-1] = l 20 | }; 21 | -------------------------------------------------------------------------------- /COPYRIGHT: -------------------------------------------------------------------------------- 1 | 2 | Copyright (c) 2000-2012 Chih-Chung Chang and Chih-Jen Lin 3 | All rights reserved. 4 | 5 | Redistribution and use in source and binary forms, with or without 6 | modification, are permitted provided that the following conditions 7 | are met: 8 | 9 | 1. Redistributions of source code must retain the above copyright 10 | notice, this list of conditions and the following disclaimer. 11 | 12 | 2. Redistributions in binary form must reproduce the above copyright 13 | notice, this list of conditions and the following disclaimer in the 14 | documentation and/or other materials provided with the distribution. 15 | 16 | 3. Neither name of copyright holders nor the names of its contributors 17 | may be used to endorse or promote products derived from this software 18 | without specific prior written permission. 19 | 20 | 21 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 | ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR 25 | CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 26 | EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 27 | PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 28 | PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 29 | LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 30 | NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 31 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 | -------------------------------------------------------------------------------- /COPYRIGHT.libsvm: -------------------------------------------------------------------------------- 1 | 2 | Copyright (c) 2000-2012 Chih-Chung Chang and Chih-Jen Lin 3 | All rights reserved. 4 | 5 | Redistribution and use in source and binary forms, with or without 6 | modification, are permitted provided that the following conditions 7 | are met: 8 | 9 | 1. Redistributions of source code must retain the above copyright 10 | notice, this list of conditions and the following disclaimer. 11 | 12 | 2. Redistributions in binary form must reproduce the above copyright 13 | notice, this list of conditions and the following disclaimer in the 14 | documentation and/or other materials provided with the distribution. 15 | 16 | 3. Neither name of copyright holders nor the names of its contributors 17 | may be used to endorse or promote products derived from this software 18 | without specific prior written permission. 19 | 20 | 21 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 | ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR 25 | CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 26 | EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 27 | PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 28 | PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 29 | LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 30 | NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 31 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 | -------------------------------------------------------------------------------- /src/ca/uwo/csd/ai/nlp/libsvm/svm_parameter.java: -------------------------------------------------------------------------------- 1 | package ca.uwo.csd.ai.nlp.libsvm; 2 | 3 | public class svm_parameter implements Cloneable, java.io.Serializable { 4 | /* svm_type */ 5 | 6 | public static final int C_SVC = 0; 7 | public static final int NU_SVC = 1; 8 | public static final int ONE_CLASS = 2; 9 | public static final int EPSILON_SVR = 3; 10 | public static final int NU_SVR = 4; 11 | 12 | /* kernel_type */ 13 | public static final int CUSTOM = 0; 14 | 15 | public int svm_type; 16 | public int kernel_type; 17 | public int degree; // for poly 18 | public double gamma; // for poly/rbf/sigmoid 19 | public double coef0; // for poly/sigmoid 20 | // these are for training only 21 | public double cache_size; // in MB 22 | public double eps; // stopping criteria 23 | public double C; // for C_SVC, EPSILON_SVR and NU_SVR 24 | public int nr_weight; // for C_SVC 25 | public int[] weight_label; // for C_SVC 26 | public double[] weight; // for C_SVC 27 | public double nu; // for NU_SVC, ONE_CLASS, and NU_SVR 28 | public double p; // for EPSILON_SVR 29 | public int shrinking; // use the shrinking heuristics 30 | public int probability; // do probability estimates 31 | 32 | 33 | public svm_parameter() { 34 | svm_type = svm_parameter.C_SVC; 35 | kernel_type = svm_parameter.CUSTOM; 36 | degree = 3; 37 | gamma = 0; // 1/num_features 38 | coef0 = 0; 39 | nu = 0.5; 40 | cache_size = 100; 41 | C = 1; 42 | eps = 1e-3; 43 | p = 0.1; 44 | shrinking = 1; 45 | probability = 0; 46 | nr_weight = 0; 47 | weight_label = new int[0]; 48 | weight = new double[0]; 49 | } 50 | 51 | public Object clone() { 52 | try { 53 | return super.clone(); 54 | } catch (CloneNotSupportedException e) { 55 | return null; 56 | } 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /src/ca/uwo/csd/ai/nlp/kernel/RBFKernel.java: -------------------------------------------------------------------------------- 1 | package ca.uwo.csd.ai.nlp.kernel; 2 | 3 | import ca.uwo.csd.ai.nlp.common.SparseVector; 4 | import ca.uwo.csd.ai.nlp.libsvm.svm_node; 5 | import ca.uwo.csd.ai.nlp.common.SparseVector.Element; 6 | import ca.uwo.csd.ai.nlp.libsvm.svm_parameter; 7 | 8 | /** 9 | * RBFKernel implements an RBF kernel. 10 | * @author Syeed Ibn Faiz 11 | */ 12 | public class RBFKernel implements CustomKernel { 13 | 14 | svm_parameter param; 15 | public RBFKernel(svm_parameter param) { 16 | this.param = param; 17 | } 18 | 19 | 20 | @Override 21 | public double evaluate(svm_node x, svm_node y) { 22 | if (!(x.data instanceof SparseVector) || !(y.data instanceof SparseVector)) { 23 | throw new RuntimeException("svm_nodes should contain sparse vectors."); 24 | } 25 | 26 | SparseVector v1 = (SparseVector) x.data; 27 | SparseVector v2 = (SparseVector) y.data; 28 | double result = 0.0; 29 | int i = 0; 30 | int j = 0; 31 | 32 | while (i < v1.size() && j < v2.size()) { 33 | Element e1 = v1.get(i); 34 | Element e2 = v2.get(j); 35 | 36 | if (e1.index == e2.index) { 37 | double d = e1.value - e2.value; 38 | result += d * d; 39 | i++; 40 | j++; 41 | } else if (e1.index < e2.index) { 42 | result += e1.value * e1.value; 43 | i++; 44 | } else { 45 | result += e2.value * e2.value; 46 | j++; 47 | } 48 | } 49 | 50 | while (i < v1.size()) { 51 | Element e1 = v1.get(i); 52 | result += e1.value * e1.value; 53 | i++; 54 | } 55 | 56 | while (j < v2.size()) { 57 | Element e2 = v2.get(j); 58 | result += e2.value * e2.value; 59 | j++; 60 | } 61 | 62 | //System.out.println("score: " + result); 63 | return Math.exp(-param.gamma * result); 64 | } 65 | 66 | } 67 | -------------------------------------------------------------------------------- /src/utils/DataFileReader.java: -------------------------------------------------------------------------------- 1 | package utils; 2 | 3 | import ca.uwo.csd.ai.nlp.common.SparseVector; 4 | import java.io.BufferedReader; 5 | import java.io.FileReader; 6 | import java.io.IOException; 7 | import java.util.ArrayList; 8 | import ca.uwo.csd.ai.nlp.libsvm.ex.Instance; 9 | 10 | /** 11 | * DataFileReader reads data files written in LibSVM format. 12 | * @author Syeed Ibn Faiz 13 | */ 14 | public class DataFileReader { 15 | 16 | public static Instance[] readDataFile(String fileName) throws IOException { 17 | BufferedReader reader = new BufferedReader(new FileReader(fileName)); 18 | 19 | ArrayList labels = new ArrayList(); 20 | ArrayList vectors = new ArrayList(); 21 | 22 | String line; 23 | int lineCount = 0; 24 | while ((line = reader.readLine()) != null) { 25 | lineCount++; 26 | String[] tokens = line.split("\\s+"); 27 | if (tokens.length < 2) { 28 | System.err.println("Inappropriate file format: " + fileName); 29 | System.err.println("Error in line " + lineCount); 30 | System.exit(-1); 31 | } 32 | 33 | labels.add(Double.parseDouble(tokens[0])); 34 | SparseVector vector = new SparseVector(tokens.length - 1); 35 | 36 | for (int i = 1; i < tokens.length; i++) { 37 | String[] fields = tokens[i].split(":"); 38 | if (fields.length < 2) { 39 | System.err.println("Inappropriate file format: " + fileName); 40 | System.err.println("Error in line " + lineCount); 41 | System.exit(-1); 42 | } 43 | int index = Integer.parseInt(fields[0]); 44 | double value = Double.parseDouble(fields[1]); 45 | vector.add(index, value); 46 | } 47 | 48 | vectors.add(vector); 49 | } 50 | 51 | Instance[] instances = new Instance[labels.size()]; 52 | for (int i = 0; i < instances.length; i++) { 53 | instances[i] = new Instance(labels.get(i), vectors.get(i)); 54 | } 55 | 56 | return instances; 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /nbproject/project.properties: -------------------------------------------------------------------------------- 1 | annotation.processing.enabled=true 2 | annotation.processing.enabled.in.editor=false 3 | annotation.processing.run.all.processors=true 4 | annotation.processing.source.output=${build.generated.sources.dir}/ap-source-output 5 | application.title=libsvm-java 6 | application.vendor=tonatuni 7 | build.classes.dir=${build.dir}/classes 8 | build.classes.excludes=**/*.java,**/*.form 9 | # This directory is removed when the project is cleaned: 10 | build.dir=build 11 | build.generated.dir=${build.dir}/generated 12 | build.generated.sources.dir=${build.dir}/generated-sources 13 | # Only compile against the classpath explicitly listed here: 14 | build.sysclasspath=ignore 15 | build.test.classes.dir=${build.dir}/test/classes 16 | build.test.results.dir=${build.dir}/test/results 17 | # Uncomment to specify the preferred debugger connection transport: 18 | #debug.transport=dt_socket 19 | debug.classpath=\ 20 | ${run.classpath} 21 | debug.test.classpath=\ 22 | ${run.test.classpath} 23 | # This directory is removed when the project is cleaned: 24 | dist.dir=dist 25 | dist.jar=${dist.dir}/libsvm-java.jar 26 | dist.javadoc.dir=${dist.dir}/javadoc 27 | endorsed.classpath= 28 | excludes= 29 | includes=** 30 | jar.compress=false 31 | javac.classpath= 32 | # Space-separated list of extra javac options 33 | javac.compilerargs= 34 | javac.deprecation=false 35 | javac.processorpath=\ 36 | ${javac.classpath} 37 | javac.source=1.6 38 | javac.target=1.6 39 | javac.test.classpath=\ 40 | ${javac.classpath}:\ 41 | ${build.classes.dir} 42 | javac.test.processorpath=\ 43 | ${javac.test.classpath} 44 | javadoc.additionalparam= 45 | javadoc.author=false 46 | javadoc.encoding=${source.encoding} 47 | javadoc.noindex=false 48 | javadoc.nonavbar=false 49 | javadoc.notree=false 50 | javadoc.private=false 51 | javadoc.splitindex=true 52 | javadoc.use=true 53 | javadoc.version=false 54 | javadoc.windowtitle= 55 | main.class= 56 | manifest.file=manifest.mf 57 | meta.inf.dir=${src.dir}/META-INF 58 | mkdist.disabled=false 59 | platform.active=default_platform 60 | run.classpath=\ 61 | ${javac.classpath}:\ 62 | ${build.classes.dir} 63 | # Space-separated list of JVM arguments used when running the project 64 | # (you may also define separate properties like run-sys-prop.name=value instead of -Dname=value 65 | # or test-sys-prop.name=value to set system properties for unit tests): 66 | run.jvmargs= 67 | run.test.classpath=\ 68 | ${javac.test.classpath}:\ 69 | ${build.test.classes.dir} 70 | source.encoding=UTF-8 71 | src.dir=src 72 | test.src.dir=test 73 | -------------------------------------------------------------------------------- /src/Demo.java: -------------------------------------------------------------------------------- 1 | 2 | import java.io.BufferedWriter; 3 | import java.io.FileWriter; 4 | import java.io.IOException; 5 | import ca.uwo.csd.ai.nlp.kernel.KernelManager; 6 | import ca.uwo.csd.ai.nlp.kernel.LinearKernel; 7 | import ca.uwo.csd.ai.nlp.libsvm.ex.Instance; 8 | import ca.uwo.csd.ai.nlp.libsvm.ex.SVMPredictor; 9 | import ca.uwo.csd.ai.nlp.libsvm.ex.SVMTrainer; 10 | import ca.uwo.csd.ai.nlp.libsvm.svm_model; 11 | import ca.uwo.csd.ai.nlp.libsvm.svm_parameter; 12 | import utils.DataFileReader; 13 | 14 | /** 15 | * Demonstration of sample usage 16 | * @author Syeed Ibn Faiz 17 | */ 18 | public class Demo { 19 | 20 | public static void testLinearKernel(String[] args) throws IOException, ClassNotFoundException { 21 | String trainFileName = args[0]; 22 | String testFileName = args[1]; 23 | String outputFileName = args[2]; 24 | 25 | //Read training file 26 | Instance[] trainingInstances = DataFileReader.readDataFile(trainFileName); 27 | 28 | //Register kernel function 29 | KernelManager.setCustomKernel(new LinearKernel()); 30 | 31 | //Setup parameters 32 | svm_parameter param = new svm_parameter(); 33 | 34 | //Train the model 35 | System.out.println("Training started..."); 36 | svm_model model = SVMTrainer.train(trainingInstances, param); 37 | System.out.println("Training completed."); 38 | 39 | //Save the trained model 40 | //SVMTrainer.saveModel(model, "a1a.model"); 41 | //model = SVMPredictor.load_model("a1a.model"); 42 | 43 | //Read test file 44 | Instance[] testingInstances = DataFileReader.readDataFile(testFileName); 45 | //Predict results 46 | double[] predictions = SVMPredictor.predict(testingInstances, model, true); 47 | writeOutputs(outputFileName, predictions); 48 | //SVMTrainer.doCrossValidation(trainingInstances, param, 10, true); 49 | //SVMTrainer.doInOrderCrossValidation(trainingInstances, param, 10, true); 50 | } 51 | 52 | private static void writeOutputs(String outputFileName, double[] predictions) throws IOException { 53 | BufferedWriter writer = new BufferedWriter(new FileWriter(outputFileName)); 54 | for (double p : predictions) { 55 | writer.write(String.format("%.0f\n", p)); 56 | } 57 | writer.close(); 58 | } 59 | 60 | private static void showUsage() { 61 | System.out.println("Demo training-file testing-file output-file"); 62 | } 63 | 64 | private static boolean checkArgument(String[] args) { 65 | return args.length == 3; 66 | } 67 | 68 | public static void main(String[] args) throws IOException, ClassNotFoundException { 69 | if (checkArgument(args)) { 70 | testLinearKernel(args); 71 | } else { 72 | showUsage(); 73 | } 74 | } 75 | 76 | } 77 | -------------------------------------------------------------------------------- /src/ca/uwo/csd/ai/nlp/libsvm/ex/SVMPredictor.java: -------------------------------------------------------------------------------- 1 | package ca.uwo.csd.ai.nlp.libsvm.ex; 2 | 3 | import ca.uwo.csd.ai.nlp.libsvm.svm; 4 | import ca.uwo.csd.ai.nlp.libsvm.svm_model; 5 | import ca.uwo.csd.ai.nlp.libsvm.svm_node; 6 | import java.io.IOException; 7 | import java.util.List; 8 | 9 | /** 10 | * 11 | * @author Syeed Ibn Faiz 12 | */ 13 | public class SVMPredictor { 14 | 15 | public static double[] predict(List instances, svm_model model) { 16 | return predict(instances, model, true); 17 | } 18 | 19 | public static double[] predict(List instances, svm_model model, boolean displayResult) { 20 | Instance[] array = new Instance[instances.size()]; 21 | array = instances.toArray(array); 22 | return predict(array, model, displayResult); 23 | } 24 | 25 | public static double predict(Instance instance, svm_model model, boolean displayResult) { 26 | return svm.svm_predict(model, new svm_node(instance.getData())); 27 | } 28 | 29 | public static double predictProbability(Instance instance, svm_model model, double[] probabilities) { 30 | return svm.svm_predict_probability(model, new svm_node(instance.getData()), probabilities); 31 | } 32 | public static double[] predict(Instance[] instances, svm_model model, boolean displayResult) { 33 | int total = 0; 34 | int correct = 0; 35 | 36 | int tp = 0; 37 | int fp = 0; 38 | int fn = 0; 39 | 40 | boolean binary = model.nr_class == 2; 41 | double[] predictions = new double[instances.length]; 42 | int count = 0; 43 | 44 | for (Instance instance : instances) { 45 | double target = instance.getLabel(); 46 | double p = svm.svm_predict(model, new svm_node(instance.getData())); 47 | predictions[count++] = p; 48 | 49 | ++total; 50 | if (p == target) { 51 | correct++; 52 | if (target > 0) { 53 | tp++; 54 | } 55 | } else if (target > 0) { 56 | fn++; 57 | } else { 58 | fp++; 59 | } 60 | } 61 | if (displayResult) { 62 | System.out.print("Accuracy = " + (double) correct / total * 100 63 | + "% (" + correct + "/" + total + ") (classification)\n"); 64 | 65 | if (binary) { 66 | double precision = (double) tp / (tp + fp); 67 | double recall = (double) tp / (tp + fn); 68 | System.out.println("Precision: " + precision); 69 | System.out.println("Recall: " + recall); 70 | System.out.println("Fscore: " + 2 * precision * recall / (precision + recall)); 71 | } 72 | } 73 | return predictions; 74 | } 75 | 76 | public static svm_model loadModel(String filePath) throws IOException, ClassNotFoundException { 77 | return svm.svm_load_model(filePath); 78 | } 79 | } 80 | -------------------------------------------------------------------------------- /src/ca/uwo/csd/ai/nlp/kernel/TreeKernel.java: -------------------------------------------------------------------------------- 1 | package ca.uwo.csd.ai.nlp.kernel; 2 | 3 | //import edu.stanford.nlp.trees.Tree; 4 | import ca.uwo.csd.ai.nlp.common.Tree; 5 | import java.util.ArrayList; 6 | import java.util.List; 7 | import ca.uwo.csd.ai.nlp.libsvm.svm_node; 8 | 9 | /** 10 | * TreeKernel provides a naive implementation of the kernel function described in 11 | * 'Parsing with a single neuron: Convolution kernels for NLP problems'. 12 | * @author Syeed Ibn Faiz 13 | */ 14 | public class TreeKernel implements CustomKernel { 15 | private final static int MAX_NODE = 300; 16 | double mem[][] = new double[MAX_NODE][MAX_NODE]; 17 | private double lambda; //penalizing factor 18 | 19 | public TreeKernel() { 20 | this(0.5); 21 | } 22 | 23 | public TreeKernel(double lambda) { 24 | this.lambda = lambda; 25 | } 26 | 27 | @Override 28 | public double evaluate(svm_node x, svm_node y) { 29 | Object k1 = x.data; 30 | Object k2 = y.data; 31 | 32 | if (!(k1 instanceof Tree) || !(k2 instanceof Tree)) { 33 | throw new IllegalArgumentException("svm_node does not contain tree data."); 34 | } 35 | 36 | Tree t1 = (Tree) k1; 37 | Tree t2 = (Tree) k2; 38 | 39 | List nodes1 = getNodes(t1); 40 | List nodes2 = getNodes(t2); 41 | 42 | int N1 = Math.min(MAX_NODE, nodes1.size()); 43 | int N2 = Math.min(MAX_NODE, nodes2.size()); 44 | 45 | //fill mem with -1.0 46 | initMem(mem, N1, N2); 47 | 48 | double result = 0.0; 49 | for (int i = 0; i < N1; i++) { 50 | for (int j = 0; j < N2; j++) { 51 | result += compute(i, j, nodes1, nodes2, mem); 52 | } 53 | } 54 | 55 | return result; 56 | } 57 | 58 | /** 59 | * Efficient computation avoiding costly equals method of Tree 60 | * @param trees 61 | * @param t 62 | * @return 63 | */ 64 | private int indexOf(List trees, Tree t) { 65 | for (int i = 0; i < trees.size(); i++) { 66 | if (t == trees.get(i)) { 67 | return i; 68 | } 69 | } 70 | return -1; 71 | } 72 | 73 | private double compute(int i, int j, List nodes1, List nodes2, double[][] mem) { 74 | if (mem[i][j] >= 0) { 75 | return mem[i][j]; 76 | } 77 | //if (sameProduction(nodes1.get(i), nodes2.get(j))) { 78 | if (nodes1.get(i).value().equals(nodes2.get(j).value()) && 79 | nodes1.get(i).hashCode() == nodes2.get(j).hashCode()) { //similar hashCode -> same production 80 | 81 | mem[i][j] = lambda * lambda; 82 | if (!nodes1.get(i).isLeaf() && !nodes2.get(j).isLeaf()) { 83 | List childList1 = nodes1.get(i).getChildrenAsList(); 84 | List childList2 = nodes2.get(j).getChildrenAsList(); 85 | for (int k = 0; k < childList1.size(); k++) { 86 | //mem[i][j] *= 1 + compute(nodes1.indexOf(childList1.get(k)), nodes2.indexOf(childList2.get(k)), nodes1, nodes2, mem); 87 | mem[i][j] *= 1 + compute(indexOf(nodes1, childList1.get(k)), indexOf(nodes2, childList2.get(k)), nodes1, nodes2, mem); 88 | } 89 | } 90 | } else { 91 | mem[i][j] = 0.0; 92 | } 93 | 94 | return mem[i][j]; 95 | } 96 | 97 | private boolean sameProduction(Tree t1, Tree t2) { 98 | if (t1.value().equals(t2.value())) { 99 | List childList1 = t1.getChildrenAsList(); 100 | List childList2 = t2.getChildrenAsList(); 101 | if (childList1.size() == childList2.size()) { 102 | for (int i = 0; i < childList1.size(); i++) { 103 | if (!childList1.get(i).value().equals(childList2.get(i).value())) { 104 | return false; 105 | } 106 | } 107 | return true; 108 | } 109 | } 110 | return false; 111 | } 112 | private void initMem(double[][] mem, int N1, int N2) { 113 | for (int i = 0; i < N1; i++) { 114 | for (int j = 0; j < N2; j++) { 115 | mem[i][j] = -1.0; 116 | } 117 | } 118 | } 119 | private List getNodes(Tree t) { 120 | ArrayList nodes = new ArrayList(); 121 | addNodes(t, nodes); 122 | return nodes; 123 | } 124 | 125 | private void addNodes(Tree t, List nodes) { 126 | nodes.add(t); 127 | List childList = t.getChildrenAsList(); 128 | for (Tree child : childList) { 129 | addNodes(child, nodes); 130 | } 131 | } 132 | } 133 | -------------------------------------------------------------------------------- /src/ca/uwo/csd/ai/nlp/common/SparseVector.java: -------------------------------------------------------------------------------- 1 | package ca.uwo.csd.ai.nlp.common; 2 | 3 | import java.io.Serializable; 4 | import java.util.Arrays; 5 | 6 | /** 7 | * SparseVector stores a sparse vector in a memory 8 | * efficient manner. It stores the elements of a vector 9 | * as a list of index:value pairs. 10 | * @author Syeed Ibn Faiz 11 | */ 12 | public class SparseVector implements Serializable { 13 | 14 | public static class Element implements Serializable, Comparable { 15 | public int index; 16 | public double value; 17 | 18 | public Element(int index, double value) { 19 | this.index = index; 20 | this.value = value; 21 | } 22 | 23 | @Override 24 | public int compareTo(Element o) { 25 | if (index < o.index) { 26 | return -1; 27 | } else if (index > o.index) { 28 | return 1; 29 | } 30 | return 0; 31 | } 32 | } 33 | 34 | private Element[] elements; 35 | private int size; 36 | private final int MAX_SIZE = 100; 37 | 38 | public SparseVector(int capacity) { 39 | elements = new Element[capacity]; 40 | } 41 | 42 | public SparseVector() { 43 | elements = new Element[MAX_SIZE]; 44 | } 45 | 46 | public void add(int index, double value) { 47 | add(new Element(index, value)); 48 | } 49 | 50 | public void add(Element elem) { 51 | if (isFull()) { 52 | resize(); 53 | } 54 | elements[size++] = elem; 55 | } 56 | 57 | public Element get(int n) { 58 | if (n >= size) { 59 | return null; 60 | } 61 | return elements[n]; 62 | } 63 | 64 | public boolean isFull() { 65 | return size == elements.length; 66 | } 67 | 68 | public boolean isEmpty() { 69 | return size == 0; 70 | } 71 | 72 | public int size() { 73 | return size; 74 | } 75 | 76 | private void resize() { 77 | Element[] newElements = new Element[size + MAX_SIZE]; 78 | for (int i = 0; i < elements.length; i++) { 79 | newElements[i] = elements[i]; 80 | elements[i] = null; 81 | } 82 | elements = newElements; 83 | } 84 | 85 | public void sortByIndices() { 86 | Arrays.sort(elements, 0, size); 87 | } 88 | 89 | @Override 90 | public String toString() { 91 | StringBuilder sb = new StringBuilder(); 92 | for (int i = 0; i < size; i++) { 93 | Element element = elements[i]; 94 | sb.append(element.index).append(":").append(element.value).append(" "); 95 | } 96 | return sb.toString(); 97 | } 98 | /** 99 | * Computes dot product between this vector and the argument vector 100 | * @param vector 101 | * @return 102 | */ 103 | public double dot(SparseVector vector) { 104 | SparseVector v1 = this; 105 | SparseVector v2 = vector; 106 | double result = 0.0; 107 | int i = 0; 108 | int j = 0; 109 | 110 | while (i < v1.size() && j < v2.size()) { 111 | Element e1 = v1.get(i); 112 | Element e2 = v2.get(j); 113 | 114 | if (e1.index == e2.index) { 115 | result += e1.value * e2.value; 116 | i++; 117 | j++; 118 | } else if (e1.index < e2.index) { 119 | i++; 120 | } else { 121 | j++; 122 | } 123 | } 124 | 125 | return result; 126 | } 127 | 128 | /** 129 | * Computes normalized dot product 130 | * @param vector 131 | * @return a positive real number in the range [0.0,1.0] 132 | */ 133 | public double normDot(SparseVector vector) { 134 | double dot = this.dot(vector); 135 | double d = Math.sqrt(this.size() * vector.size()); 136 | if (d > 0) { 137 | dot /= d; 138 | } 139 | return dot; 140 | } 141 | 142 | /** 143 | * Computes square of the Euclidean distance 144 | * @param vector 145 | * @return 146 | */ 147 | public double squaredDistance(SparseVector vector) { 148 | SparseVector v1 = this; 149 | SparseVector v2 = vector; 150 | double result = 0.0; 151 | int i = 0; 152 | int j = 0; 153 | 154 | while (i < v1.size() && j < v2.size()) { 155 | Element e1 = v1.get(i); 156 | Element e2 = v2.get(j); 157 | 158 | if (e1.index == e2.index) { 159 | double d = e1.value - e2.value; 160 | result += d*d; 161 | i++; 162 | j++; 163 | } else if (e1.index < e2.index) { 164 | result += e1.value * e1.value; 165 | i++; 166 | } else { 167 | result += e2.value * e2.value; 168 | j++; 169 | } 170 | } 171 | 172 | while (i < v1.size()) { 173 | Element e1 = v1.get(i); 174 | result += e1.value * e1.value; 175 | i++; 176 | } 177 | 178 | while (j < v2.size()) { 179 | Element e2 = v2.get(j); 180 | result += e2.value * e2.value; 181 | j++; 182 | } 183 | return result; 184 | } 185 | 186 | public void removeDuplicates() { 187 | int last = 0; 188 | for (int i = 1; i < size; i++) { 189 | if (elements[last].index != elements[i].index) { 190 | last++; 191 | elements[last] = elements[i]; 192 | } 193 | } 194 | size = last + 1; 195 | } 196 | 197 | public static void main(String[] args) { 198 | SparseVector vector = new SparseVector(); 199 | vector.add(3, 1.2); 200 | vector.add(3, 1.2); 201 | vector.add(1, 1.6); 202 | vector.add(1, 1.6); 203 | vector.add(5, 2.3); 204 | vector.add(3, 1.2); 205 | vector.add(5, 2.3); 206 | vector.add(1, 1.6); 207 | vector.add(1, 1.6); 208 | System.out.println("before: " + vector); 209 | vector.sortByIndices(); 210 | System.out.println("after: " + vector); 211 | vector.removeDuplicates(); 212 | System.out.println("after: " + vector); 213 | } 214 | } 215 | -------------------------------------------------------------------------------- /src/ca/uwo/csd/ai/nlp/libsvm/ex/SVMTrainer.java: -------------------------------------------------------------------------------- 1 | package ca.uwo.csd.ai.nlp.libsvm.ex; 2 | 3 | 4 | import ca.uwo.csd.ai.nlp.libsvm.svm; 5 | import ca.uwo.csd.ai.nlp.libsvm.svm_model; 6 | import ca.uwo.csd.ai.nlp.libsvm.svm_node; 7 | import ca.uwo.csd.ai.nlp.libsvm.svm_parameter; 8 | import ca.uwo.csd.ai.nlp.libsvm.svm_problem; 9 | import java.io.IOException; 10 | import java.util.ArrayList; 11 | import java.util.List; 12 | 13 | /** 14 | * SVMTrainer performs training of an SVM. 15 | * @author Syeed Ibn Faiz 16 | */ 17 | public class SVMTrainer { 18 | 19 | private static svm_problem prepareProblem(List instances) { 20 | Instance[] array = new Instance[instances.size()]; 21 | array = instances.toArray(array); 22 | return prepareProblem(array); 23 | } 24 | 25 | private static svm_problem prepareProblem(Instance[] instances) { 26 | return prepareProblem(instances, 0, instances.length - 1); 27 | } 28 | 29 | private static svm_problem prepareProblem(Instance[] instances, int begin, int end) { 30 | svm_problem prob = new svm_problem(); 31 | prob.l = (end - begin) + 1; 32 | prob.y = new double[prob.l]; 33 | prob.x = new svm_node[prob.l]; 34 | 35 | for (int i = begin; i <= end; i++) { 36 | prob.y[i-begin] = instances[i].getLabel(); 37 | prob.x[i-begin] = new svm_node(instances[i].getData()); 38 | } 39 | return prob; 40 | } 41 | 42 | /** 43 | * Builds an SVM model 44 | * @param instances 45 | * @param param 46 | * @return 47 | */ 48 | public static svm_model train(Instance[] instances, svm_parameter param) { 49 | //prepare svm_problem 50 | svm_problem prob = prepareProblem(instances); 51 | 52 | String error_msg = svm.svm_check_parameter(prob, param); 53 | 54 | if (error_msg != null) { 55 | System.err.print("ERROR: " + error_msg + "\n"); 56 | System.exit(1); 57 | } 58 | 59 | return svm.svm_train(prob, param); 60 | } 61 | 62 | public static svm_model train(List instances, svm_parameter param) { 63 | Instance[] array = new Instance[instances.size()]; 64 | array = instances.toArray(array); 65 | return train(array, param); 66 | } 67 | 68 | /** 69 | * Performs N-fold cross validation 70 | * @param instances 71 | * @param param parameters 72 | * @param nr_fold number of folds (N) 73 | * @param binary whether doing binary classification 74 | */ 75 | public static void doCrossValidation(Instance[] instances, svm_parameter param, int nr_fold, boolean binary) { 76 | svm_problem prob = prepareProblem(instances); 77 | 78 | int i; 79 | int total_correct = 0; 80 | double total_error = 0; 81 | double sumv = 0, sumy = 0, sumvv = 0, sumyy = 0, sumvy = 0; 82 | double[] target = new double[prob.l]; 83 | 84 | svm.svm_cross_validation(prob, param, nr_fold, target); 85 | if (param.svm_type == svm_parameter.EPSILON_SVR 86 | || param.svm_type == svm_parameter.NU_SVR) { 87 | for (i = 0; i < prob.l; i++) { 88 | double y = prob.y[i]; 89 | double v = target[i]; 90 | total_error += (v - y) * (v - y); 91 | sumv += v; 92 | sumy += y; 93 | sumvv += v * v; 94 | sumyy += y * y; 95 | sumvy += v * y; 96 | } 97 | System.out.print("Cross Validation Mean squared error = " + total_error / prob.l + "\n"); 98 | System.out.print("Cross Validation Squared correlation coefficient = " 99 | + ((prob.l * sumvy - sumv * sumy) * (prob.l * sumvy - sumv * sumy)) 100 | / ((prob.l * sumvv - sumv * sumv) * (prob.l * sumyy - sumy * sumy)) + "\n"); 101 | } else { 102 | int tp = 0; 103 | int fp = 0; 104 | int fn = 0; 105 | 106 | for (i = 0; i < prob.l; i++) { 107 | if (target[i] == prob.y[i]) { 108 | ++total_correct; 109 | if (prob.y[i] > 0) { 110 | tp++; 111 | } 112 | } else if (prob.y[i] > 0) { 113 | fn++; 114 | } else if (prob.y[i] < 0) { 115 | fp++; 116 | } 117 | } 118 | System.out.print("Cross Validation Accuracy = " + 100.0 * total_correct / prob.l + "%\n"); 119 | if (binary) { 120 | double precision = (double) tp / (tp + fp); 121 | double recall = (double) tp / (tp + fn); 122 | System.out.println("Precision: " + precision); 123 | System.out.println("Recall: " + recall); 124 | System.out.println("FScore: " + 2 * precision * recall / (precision + recall)); 125 | } 126 | } 127 | } 128 | 129 | public static void doInOrderCrossValidation(Instance[] instances, svm_parameter param, int nr_fold, boolean binary) { 130 | int size = instances.length; 131 | int chunkSize = size/nr_fold; 132 | int begin = 0; 133 | int end = chunkSize - 1; 134 | int tp = 0; 135 | int fp = 0; 136 | int fn = 0; 137 | int total = 0; 138 | 139 | for (int i = 0; i < nr_fold; i++) { 140 | System.out.println("Iteration: " + (i+1)); 141 | List trainingInstances = new ArrayList(); 142 | List testingInstances = new ArrayList(); 143 | for (int j = 0; j < size; j++) { 144 | if (j >= begin && j <= end) { 145 | testingInstances.add(instances[j]); 146 | } else { 147 | trainingInstances.add(instances[j]); 148 | } 149 | } 150 | 151 | svm_model trainModel = train(trainingInstances, param); 152 | double[] predictions = SVMPredictor.predict(testingInstances, trainModel); 153 | for (int k = 0; k < predictions.length; k++) { 154 | 155 | if (predictions[k] == testingInstances.get(k).getLabel()) { 156 | //if (Math.abs(predictions[k] - testingInstances.get(k).getLabel()) < 0.00001) { 157 | if (testingInstances.get(k).getLabel() > 0) { 158 | tp++; 159 | } 160 | } else if (testingInstances.get(k).getLabel() > 0) { 161 | fn++; 162 | } else if (testingInstances.get(k).getLabel() < 0) { 163 | //System.out.println(testingInstances.get(k).getData()); 164 | fp++; 165 | } 166 | total++; 167 | } 168 | //update 169 | begin = end+1; 170 | end = begin + chunkSize - 1; 171 | if (end >= size) { 172 | end = size-1; 173 | } 174 | } 175 | 176 | double precision = (double) tp / (tp + fp); 177 | double recall = (double) tp / (tp + fn); 178 | System.out.println("Precision: " + precision); 179 | System.out.println("Recall: " + recall); 180 | System.out.println("FScore: " + 2 * precision * recall / (precision + recall)); 181 | } 182 | 183 | public static void saveModel(svm_model model, String filePath) throws IOException { 184 | svm.svm_save_model(filePath, model); 185 | } 186 | } 187 | -------------------------------------------------------------------------------- /src/svm_scale.java: -------------------------------------------------------------------------------- 1 | 2 | import java.io.*; 3 | import java.util.*; 4 | 5 | class svm_scale { 6 | 7 | private String line = null; 8 | private double lower = -1.0; 9 | private double upper = 1.0; 10 | private double y_lower; 11 | private double y_upper; 12 | private boolean y_scaling = false; 13 | private double[] feature_max; 14 | private double[] feature_min; 15 | private double y_max = -Double.MAX_VALUE; 16 | private double y_min = Double.MAX_VALUE; 17 | private int max_index; 18 | private long num_nonzeros = 0; 19 | private long new_num_nonzeros = 0; 20 | 21 | private static void exit_with_help() { 22 | System.out.print( 23 | "Usage: svm-scale [options] data_filename\n" 24 | + "options:\n" 25 | + "-l lower : x scaling lower limit (default -1)\n" 26 | + "-u upper : x scaling upper limit (default +1)\n" 27 | + "-y y_lower y_upper : y scaling limits (default: no y scaling)\n" 28 | + "-s save_filename : save scaling parameters to save_filename\n" 29 | + "-r restore_filename : restore scaling parameters from restore_filename\n"); 30 | System.exit(1); 31 | } 32 | 33 | private BufferedReader rewind(BufferedReader fp, String filename) throws IOException { 34 | fp.close(); 35 | return new BufferedReader(new FileReader(filename)); 36 | } 37 | 38 | private void output_target(double value) { 39 | if (y_scaling) { 40 | if (value == y_min) { 41 | value = y_lower; 42 | } else if (value == y_max) { 43 | value = y_upper; 44 | } else { 45 | value = y_lower + (y_upper - y_lower) 46 | * (value - y_min) / (y_max - y_min); 47 | } 48 | } 49 | 50 | System.out.print(value + " "); 51 | } 52 | 53 | private void output(int index, double value) { 54 | /* skip single-valued attribute */ 55 | if (feature_max[index] == feature_min[index]) { 56 | return; 57 | } 58 | 59 | if (value == feature_min[index]) { 60 | value = lower; 61 | } else if (value == feature_max[index]) { 62 | value = upper; 63 | } else { 64 | value = lower + (upper - lower) 65 | * (value - feature_min[index]) 66 | / (feature_max[index] - feature_min[index]); 67 | } 68 | 69 | if (value != 0) { 70 | System.out.print(index + ":" + value + " "); 71 | new_num_nonzeros++; 72 | } 73 | } 74 | 75 | private String readline(BufferedReader fp) throws IOException { 76 | line = fp.readLine(); 77 | return line; 78 | } 79 | 80 | private void run(String[] argv) throws IOException { 81 | int i, index; 82 | BufferedReader fp = null, fp_restore = null; 83 | String save_filename = null; 84 | String restore_filename = null; 85 | String data_filename = null; 86 | 87 | 88 | for (i = 0; i < argv.length; i++) { 89 | if (argv[i].charAt(0) != '-') { 90 | break; 91 | } 92 | ++i; 93 | switch (argv[i - 1].charAt(1)) { 94 | case 'l': 95 | lower = Double.parseDouble(argv[i]); 96 | break; 97 | case 'u': 98 | upper = Double.parseDouble(argv[i]); 99 | break; 100 | case 'y': 101 | y_lower = Double.parseDouble(argv[i]); 102 | ++i; 103 | y_upper = Double.parseDouble(argv[i]); 104 | y_scaling = true; 105 | break; 106 | case 's': 107 | save_filename = argv[i]; 108 | break; 109 | case 'r': 110 | restore_filename = argv[i]; 111 | break; 112 | default: 113 | System.err.println("unknown option"); 114 | exit_with_help(); 115 | } 116 | } 117 | 118 | if (!(upper > lower) || (y_scaling && !(y_upper > y_lower))) { 119 | System.err.println("inconsistent lower/upper specification"); 120 | System.exit(1); 121 | } 122 | if (restore_filename != null && save_filename != null) { 123 | System.err.println("cannot use -r and -s simultaneously"); 124 | System.exit(1); 125 | } 126 | 127 | if (argv.length != i + 1) { 128 | exit_with_help(); 129 | } 130 | 131 | data_filename = argv[i]; 132 | try { 133 | fp = new BufferedReader(new FileReader(data_filename)); 134 | } catch (Exception e) { 135 | System.err.println("can't open file " + data_filename); 136 | System.exit(1); 137 | } 138 | 139 | /* assumption: min index of attributes is 1 */ 140 | /* pass 1: find out max index of attributes */ 141 | max_index = 0; 142 | 143 | if (restore_filename != null) { 144 | int idx, c; 145 | 146 | try { 147 | fp_restore = new BufferedReader(new FileReader(restore_filename)); 148 | } catch (Exception e) { 149 | System.err.println("can't open file " + restore_filename); 150 | System.exit(1); 151 | } 152 | if ((c = fp_restore.read()) == 'y') { 153 | fp_restore.readLine(); 154 | fp_restore.readLine(); 155 | fp_restore.readLine(); 156 | } 157 | fp_restore.readLine(); 158 | fp_restore.readLine(); 159 | 160 | String restore_line = null; 161 | while ((restore_line = fp_restore.readLine()) != null) { 162 | StringTokenizer st2 = new StringTokenizer(restore_line); 163 | idx = Integer.parseInt(st2.nextToken()); 164 | max_index = Math.max(max_index, idx); 165 | } 166 | fp_restore = rewind(fp_restore, restore_filename); 167 | } 168 | 169 | while (readline(fp) != null) { 170 | StringTokenizer st = new StringTokenizer(line, " \t\n\r\f:"); 171 | st.nextToken(); 172 | while (st.hasMoreTokens()) { 173 | index = Integer.parseInt(st.nextToken()); 174 | max_index = Math.max(max_index, index); 175 | st.nextToken(); 176 | num_nonzeros++; 177 | } 178 | } 179 | 180 | try { 181 | feature_max = new double[(max_index + 1)]; 182 | feature_min = new double[(max_index + 1)]; 183 | } catch (OutOfMemoryError e) { 184 | System.err.println("can't allocate enough memory"); 185 | System.exit(1); 186 | } 187 | 188 | for (i = 0; i <= max_index; i++) { 189 | feature_max[i] = -Double.MAX_VALUE; 190 | feature_min[i] = Double.MAX_VALUE; 191 | } 192 | 193 | fp = rewind(fp, data_filename); 194 | 195 | /* pass 2: find out min/max value */ 196 | while (readline(fp) != null) { 197 | int next_index = 1; 198 | double target; 199 | double value; 200 | 201 | StringTokenizer st = new StringTokenizer(line, " \t\n\r\f:"); 202 | target = Double.parseDouble(st.nextToken()); 203 | y_max = Math.max(y_max, target); 204 | y_min = Math.min(y_min, target); 205 | 206 | while (st.hasMoreTokens()) { 207 | index = Integer.parseInt(st.nextToken()); 208 | value = Double.parseDouble(st.nextToken()); 209 | 210 | for (i = next_index; i < index; i++) { 211 | feature_max[i] = Math.max(feature_max[i], 0); 212 | feature_min[i] = Math.min(feature_min[i], 0); 213 | } 214 | 215 | feature_max[index] = Math.max(feature_max[index], value); 216 | feature_min[index] = Math.min(feature_min[index], value); 217 | next_index = index + 1; 218 | } 219 | 220 | for (i = next_index; i <= max_index; i++) { 221 | feature_max[i] = Math.max(feature_max[i], 0); 222 | feature_min[i] = Math.min(feature_min[i], 0); 223 | } 224 | } 225 | 226 | fp = rewind(fp, data_filename); 227 | 228 | /* pass 2.5: save/restore feature_min/feature_max */ 229 | if (restore_filename != null) { 230 | // fp_restore rewinded in finding max_index 231 | int idx, c; 232 | double fmin, fmax; 233 | 234 | fp_restore.mark(2); // for reset 235 | if ((c = fp_restore.read()) == 'y') { 236 | fp_restore.readLine(); // pass the '\n' after 'y' 237 | StringTokenizer st = new StringTokenizer(fp_restore.readLine()); 238 | y_lower = Double.parseDouble(st.nextToken()); 239 | y_upper = Double.parseDouble(st.nextToken()); 240 | st = new StringTokenizer(fp_restore.readLine()); 241 | y_min = Double.parseDouble(st.nextToken()); 242 | y_max = Double.parseDouble(st.nextToken()); 243 | y_scaling = true; 244 | } else { 245 | fp_restore.reset(); 246 | } 247 | 248 | if (fp_restore.read() == 'x') { 249 | fp_restore.readLine(); // pass the '\n' after 'x' 250 | StringTokenizer st = new StringTokenizer(fp_restore.readLine()); 251 | lower = Double.parseDouble(st.nextToken()); 252 | upper = Double.parseDouble(st.nextToken()); 253 | String restore_line = null; 254 | while ((restore_line = fp_restore.readLine()) != null) { 255 | StringTokenizer st2 = new StringTokenizer(restore_line); 256 | idx = Integer.parseInt(st2.nextToken()); 257 | fmin = Double.parseDouble(st2.nextToken()); 258 | fmax = Double.parseDouble(st2.nextToken()); 259 | if (idx <= max_index) { 260 | feature_min[idx] = fmin; 261 | feature_max[idx] = fmax; 262 | } 263 | } 264 | } 265 | fp_restore.close(); 266 | } 267 | 268 | if (save_filename != null) { 269 | Formatter formatter = new Formatter(new StringBuilder()); 270 | BufferedWriter fp_save = null; 271 | 272 | try { 273 | fp_save = new BufferedWriter(new FileWriter(save_filename)); 274 | } catch (IOException e) { 275 | System.err.println("can't open file " + save_filename); 276 | System.exit(1); 277 | } 278 | 279 | if (y_scaling) { 280 | formatter.format("y\n"); 281 | formatter.format("%.16g %.16g\n", y_lower, y_upper); 282 | formatter.format("%.16g %.16g\n", y_min, y_max); 283 | } 284 | formatter.format("x\n"); 285 | formatter.format("%.16g %.16g\n", lower, upper); 286 | for (i = 1; i <= max_index; i++) { 287 | if (feature_min[i] != feature_max[i]) { 288 | formatter.format("%d %.16g %.16g\n", i, feature_min[i], feature_max[i]); 289 | } 290 | } 291 | fp_save.write(formatter.toString()); 292 | fp_save.close(); 293 | } 294 | 295 | /* pass 3: scale */ 296 | while (readline(fp) != null) { 297 | int next_index = 1; 298 | double target; 299 | double value; 300 | 301 | StringTokenizer st = new StringTokenizer(line, " \t\n\r\f:"); 302 | target = Double.parseDouble(st.nextToken()); 303 | output_target(target); 304 | while (st.hasMoreElements()) { 305 | index = Integer.parseInt(st.nextToken()); 306 | value = Double.parseDouble(st.nextToken()); 307 | for (i = next_index; i < index; i++) { 308 | output(i, 0); 309 | } 310 | output(index, value); 311 | next_index = index + 1; 312 | } 313 | 314 | for (i = next_index; i <= max_index; i++) { 315 | output(i, 0); 316 | } 317 | System.out.print("\n"); 318 | } 319 | if (new_num_nonzeros > num_nonzeros) { 320 | System.err.print( 321 | "WARNING: original #nonzeros " + num_nonzeros + "\n" 322 | + " new #nonzeros " + new_num_nonzeros + "\n" 323 | + "Use -l 0 if many original feature values are zeros\n"); 324 | } 325 | 326 | fp.close(); 327 | } 328 | 329 | public static void main(String argv[]) throws IOException { 330 | svm_scale s = new svm_scale(); 331 | s.run(argv); 332 | } 333 | } 334 | -------------------------------------------------------------------------------- /README.libsvm: -------------------------------------------------------------------------------- 1 | Libsvm is a simple, easy-to-use, and efficient software for SVM 2 | classification and regression. It solves C-SVM classification, nu-SVM 3 | classification, one-class-SVM, epsilon-SVM regression, and nu-SVM 4 | regression. It also provides an automatic model selection tool for 5 | C-SVM classification. This document explains the use of libsvm. 6 | 7 | Libsvm is available at 8 | http://www.csie.ntu.edu.tw/~cjlin/libsvm 9 | Please read the COPYRIGHT file before using libsvm. 10 | 11 | Table of Contents 12 | ================= 13 | 14 | - Quick Start 15 | - Installation and Data Format 16 | - `svm-train' Usage 17 | - `svm-predict' Usage 18 | - `svm-scale' Usage 19 | - Tips on Practical Use 20 | - Examples 21 | - Precomputed Kernels 22 | - Library Usage 23 | - Java Version 24 | - Building Windows Binaries 25 | - Additional Tools: Sub-sampling, Parameter Selection, Format checking, etc. 26 | - MATLAB/OCTAVE Interface 27 | - Python Interface 28 | - Additional Information 29 | 30 | Quick Start 31 | =========== 32 | 33 | If you are new to SVM and if the data is not large, please go to 34 | `tools' directory and use easy.py after installation. It does 35 | everything automatic -- from data scaling to parameter selection. 36 | 37 | Usage: easy.py training_file [testing_file] 38 | 39 | More information about parameter selection can be found in 40 | `tools/README.' 41 | 42 | Installation and Data Format 43 | ============================ 44 | 45 | On Unix systems, type `make' to build the `svm-train' and `svm-predict' 46 | programs. Run them without arguments to show the usages of them. 47 | 48 | On other systems, consult `Makefile' to build them (e.g., see 49 | 'Building Windows binaries' in this file) or use the pre-built 50 | binaries (Windows binaries are in the directory `windows'). 51 | 52 | The format of training and testing data file is: 53 | 54 | : : ... 55 | . 56 | . 57 | . 58 | 59 | Each line contains an instance and is ended by a '\n' character. For 60 | classification, is an integer indicating the class label 61 | (multi-class is supported). For regression, is the target 62 | value which can be any real number. For one-class SVM, it's not used 63 | so can be any number. The pair : gives a feature 64 | (attribute) value: is an integer starting from 1 and 65 | is a real number. The only exception is the precomputed kernel, where 66 | starts from 0; see the section of precomputed kernels. Indices 67 | must be in ASCENDING order. Labels in the testing file are only used 68 | to calculate accuracy or errors. If they are unknown, just fill the 69 | first column with any numbers. 70 | 71 | A sample classification data included in this package is 72 | `heart_scale'. To check if your data is in a correct form, use 73 | `tools/checkdata.py' (details in `tools/README'). 74 | 75 | Type `svm-train heart_scale', and the program will read the training 76 | data and output the model file `heart_scale.model'. If you have a test 77 | set called heart_scale.t, then type `svm-predict heart_scale.t 78 | heart_scale.model output' to see the prediction accuracy. The `output' 79 | file contains the predicted class labels. 80 | 81 | For classification, if training data are in only one class (i.e., all 82 | labels are the same), then `svm-train' issues a warning message: 83 | `Warning: training data in only one class. See README for details,' 84 | which means the training data is very unbalanced. The label in the 85 | training data is directly returned when testing. 86 | 87 | There are some other useful programs in this package. 88 | 89 | svm-scale: 90 | 91 | This is a tool for scaling input data file. 92 | 93 | svm-toy: 94 | 95 | This is a simple graphical interface which shows how SVM 96 | separate data in a plane. You can click in the window to 97 | draw data points. Use "change" button to choose class 98 | 1, 2 or 3 (i.e., up to three classes are supported), "load" 99 | button to load data from a file, "save" button to save data to 100 | a file, "run" button to obtain an SVM model, and "clear" 101 | button to clear the window. 102 | 103 | You can enter options in the bottom of the window, the syntax of 104 | options is the same as `svm-train'. 105 | 106 | Note that "load" and "save" consider dense data format both in 107 | classification and the regression cases. For classification, 108 | each data point has one label (the color) that must be 1, 2, 109 | or 3 and two attributes (x-axis and y-axis values) in 110 | [0,1). For regression, each data point has one target value 111 | (y-axis) and one attribute (x-axis values) in [0, 1). 112 | 113 | Type `make' in respective directories to build them. 114 | 115 | You need Qt library to build the Qt version. 116 | (available from http://www.trolltech.com) 117 | 118 | You need GTK+ library to build the GTK version. 119 | (available from http://www.gtk.org) 120 | 121 | The pre-built Windows binaries are in the `windows' 122 | directory. We use Visual C++ on a 32-bit machine, so the 123 | maximal cache size is 2GB. 124 | 125 | `svm-train' Usage 126 | ================= 127 | 128 | Usage: svm-train [options] training_set_file [model_file] 129 | options: 130 | -s svm_type : set type of SVM (default 0) 131 | 0 -- C-SVC 132 | 1 -- nu-SVC 133 | 2 -- one-class SVM 134 | 3 -- epsilon-SVR 135 | 4 -- nu-SVR 136 | -t kernel_type : set type of kernel function (default 2) 137 | 0 -- linear: u'*v 138 | 1 -- polynomial: (gamma*u'*v + coef0)^degree 139 | 2 -- radial basis function: exp(-gamma*|u-v|^2) 140 | 3 -- sigmoid: tanh(gamma*u'*v + coef0) 141 | 4 -- precomputed kernel (kernel values in training_set_file) 142 | -d degree : set degree in kernel function (default 3) 143 | -g gamma : set gamma in kernel function (default 1/num_features) 144 | -r coef0 : set coef0 in kernel function (default 0) 145 | -c cost : set the parameter C of C-SVC, epsilon-SVR, and nu-SVR (default 1) 146 | -n nu : set the parameter nu of nu-SVC, one-class SVM, and nu-SVR (default 0.5) 147 | -p epsilon : set the epsilon in loss function of epsilon-SVR (default 0.1) 148 | -m cachesize : set cache memory size in MB (default 100) 149 | -e epsilon : set tolerance of termination criterion (default 0.001) 150 | -h shrinking : whether to use the shrinking heuristics, 0 or 1 (default 1) 151 | -b probability_estimates : whether to train a SVC or SVR model for probability estimates, 0 or 1 (default 0) 152 | -wi weight : set the parameter C of class i to weight*C, for C-SVC (default 1) 153 | -v n: n-fold cross validation mode 154 | -q : quiet mode (no outputs) 155 | 156 | 157 | The k in the -g option means the number of attributes in the input data. 158 | 159 | option -v randomly splits the data into n parts and calculates cross 160 | validation accuracy/mean squared error on them. 161 | 162 | See libsvm FAQ for the meaning of outputs. 163 | 164 | `svm-predict' Usage 165 | =================== 166 | 167 | Usage: svm-predict [options] test_file model_file output_file 168 | options: 169 | -b probability_estimates: whether to predict probability estimates, 0 or 1 (default 0); for one-class SVM only 0 is supported 170 | 171 | model_file is the model file generated by svm-train. 172 | test_file is the test data you want to predict. 173 | svm-predict will produce output in the output_file. 174 | 175 | `svm-scale' Usage 176 | ================= 177 | 178 | Usage: svm-scale [options] data_filename 179 | options: 180 | -l lower : x scaling lower limit (default -1) 181 | -u upper : x scaling upper limit (default +1) 182 | -y y_lower y_upper : y scaling limits (default: no y scaling) 183 | -s save_filename : save scaling parameters to save_filename 184 | -r restore_filename : restore scaling parameters from restore_filename 185 | 186 | See 'Examples' in this file for examples. 187 | 188 | Tips on Practical Use 189 | ===================== 190 | 191 | * Scale your data. For example, scale each attribute to [0,1] or [-1,+1]. 192 | * For C-SVC, consider using the model selection tool in the tools directory. 193 | * nu in nu-SVC/one-class-SVM/nu-SVR approximates the fraction of training 194 | errors and support vectors. 195 | * If data for classification are unbalanced (e.g. many positive and 196 | few negative), try different penalty parameters C by -wi (see 197 | examples below). 198 | * Specify larger cache size (i.e., larger -m) for huge problems. 199 | 200 | Examples 201 | ======== 202 | 203 | > svm-scale -l -1 -u 1 -s range train > train.scale 204 | > svm-scale -r range test > test.scale 205 | 206 | Scale each feature of the training data to be in [-1,1]. Scaling 207 | factors are stored in the file range and then used for scaling the 208 | test data. 209 | 210 | > svm-train -s 0 -c 5 -t 2 -g 0.5 -e 0.1 data_file 211 | 212 | Train a classifier with RBF kernel exp(-0.5|u-v|^2), C=10, and 213 | stopping tolerance 0.1. 214 | 215 | > svm-train -s 3 -p 0.1 -t 0 data_file 216 | 217 | Solve SVM regression with linear kernel u'v and epsilon=0.1 218 | in the loss function. 219 | 220 | > svm-train -c 10 -w1 1 -w2 5 -w4 2 data_file 221 | 222 | Train a classifier with penalty 10 = 1 * 10 for class 1, penalty 50 = 223 | 5 * 10 for class 2, and penalty 20 = 2 * 10 for class 4. 224 | 225 | > svm-train -s 0 -c 100 -g 0.1 -v 5 data_file 226 | 227 | Do five-fold cross validation for the classifier using 228 | the parameters C = 100 and gamma = 0.1 229 | 230 | > svm-train -s 0 -b 1 data_file 231 | > svm-predict -b 1 test_file data_file.model output_file 232 | 233 | Obtain a model with probability information and predict test data with 234 | probability estimates 235 | 236 | Precomputed Kernels 237 | =================== 238 | 239 | Users may precompute kernel values and input them as training and 240 | testing files. Then libsvm does not need the original 241 | training/testing sets. 242 | 243 | Assume there are L training instances x1, ..., xL and. 244 | Let K(x, y) be the kernel 245 | value of two instances x and y. The input formats 246 | are: 247 | 248 | New training instance for xi: 249 | 250 | 0:i 1:K(xi,x1) ... L:K(xi,xL) 251 | 252 | New testing instance for any x: 253 | 254 | 0:? 1:K(x,x1) ... L:K(x,xL) 255 | 256 | That is, in the training file the first column must be the "ID" of 257 | xi. In testing, ? can be any value. 258 | 259 | All kernel values including ZEROs must be explicitly provided. Any 260 | permutation or random subsets of the training/testing files are also 261 | valid (see examples below). 262 | 263 | Note: the format is slightly different from the precomputed kernel 264 | package released in libsvmtools earlier. 265 | 266 | Examples: 267 | 268 | Assume the original training data has three four-feature 269 | instances and testing data has one instance: 270 | 271 | 15 1:1 2:1 3:1 4:1 272 | 45 2:3 4:3 273 | 25 3:1 274 | 275 | 15 1:1 3:1 276 | 277 | If the linear kernel is used, we have the following new 278 | training/testing sets: 279 | 280 | 15 0:1 1:4 2:6 3:1 281 | 45 0:2 1:6 2:18 3:0 282 | 25 0:3 1:1 2:0 3:1 283 | 284 | 15 0:? 1:2 2:0 3:1 285 | 286 | ? can be any value. 287 | 288 | Any subset of the above training file is also valid. For example, 289 | 290 | 25 0:3 1:1 2:0 3:1 291 | 45 0:2 1:6 2:18 3:0 292 | 293 | implies that the kernel matrix is 294 | 295 | [K(2,2) K(2,3)] = [18 0] 296 | [K(3,2) K(3,3)] = [0 1] 297 | 298 | Library Usage 299 | ============= 300 | 301 | These functions and structures are declared in the header file 302 | `svm.h'. You need to #include "svm.h" in your C/C++ source files and 303 | link your program with `svm.cpp'. You can see `svm-train.c' and 304 | `svm-predict.c' for examples showing how to use them. We define 305 | LIBSVM_VERSION and declare `extern int libsvm_version; ' in svm.h, so 306 | you can check the version number. 307 | 308 | Before you classify test data, you need to construct an SVM model 309 | (`svm_model') using training data. A model can also be saved in 310 | a file for later use. Once an SVM model is available, you can use it 311 | to classify new data. 312 | 313 | - Function: struct svm_model *svm_train(const struct svm_problem *prob, 314 | const struct svm_parameter *param); 315 | 316 | This function constructs and returns an SVM model according to 317 | the given training data and parameters. 318 | 319 | struct svm_problem describes the problem: 320 | 321 | struct svm_problem 322 | { 323 | int l; 324 | double *y; 325 | struct svm_node **x; 326 | }; 327 | 328 | where `l' is the number of training data, and `y' is an array containing 329 | their target values. (integers in classification, real numbers in 330 | regression) `x' is an array of pointers, each of which points to a sparse 331 | representation (array of svm_node) of one training vector. 332 | 333 | For example, if we have the following training data: 334 | 335 | LABEL ATTR1 ATTR2 ATTR3 ATTR4 ATTR5 336 | ----- ----- ----- ----- ----- ----- 337 | 1 0 0.1 0.2 0 0 338 | 2 0 0.1 0.3 -1.2 0 339 | 1 0.4 0 0 0 0 340 | 2 0 0.1 0 1.4 0.5 341 | 3 -0.1 -0.2 0.1 1.1 0.1 342 | 343 | then the components of svm_problem are: 344 | 345 | l = 5 346 | 347 | y -> 1 2 1 2 3 348 | 349 | x -> [ ] -> (2,0.1) (3,0.2) (-1,?) 350 | [ ] -> (2,0.1) (3,0.3) (4,-1.2) (-1,?) 351 | [ ] -> (1,0.4) (-1,?) 352 | [ ] -> (2,0.1) (4,1.4) (5,0.5) (-1,?) 353 | [ ] -> (1,-0.1) (2,-0.2) (3,0.1) (4,1.1) (5,0.1) (-1,?) 354 | 355 | where (index,value) is stored in the structure `svm_node': 356 | 357 | struct svm_node 358 | { 359 | int index; 360 | double value; 361 | }; 362 | 363 | index = -1 indicates the end of one vector. Note that indices must 364 | be in ASCENDING order. 365 | 366 | struct svm_parameter describes the parameters of an SVM model: 367 | 368 | struct svm_parameter 369 | { 370 | int svm_type; 371 | int kernel_type; 372 | int degree; /* for poly */ 373 | double gamma; /* for poly/rbf/sigmoid */ 374 | double coef0; /* for poly/sigmoid */ 375 | 376 | /* these are for training only */ 377 | double cache_size; /* in MB */ 378 | double eps; /* stopping criteria */ 379 | double C; /* for C_SVC, EPSILON_SVR, and NU_SVR */ 380 | int nr_weight; /* for C_SVC */ 381 | int *weight_label; /* for C_SVC */ 382 | double* weight; /* for C_SVC */ 383 | double nu; /* for NU_SVC, ONE_CLASS, and NU_SVR */ 384 | double p; /* for EPSILON_SVR */ 385 | int shrinking; /* use the shrinking heuristics */ 386 | int probability; /* do probability estimates */ 387 | }; 388 | 389 | svm_type can be one of C_SVC, NU_SVC, ONE_CLASS, EPSILON_SVR, NU_SVR. 390 | 391 | C_SVC: C-SVM classification 392 | NU_SVC: nu-SVM classification 393 | ONE_CLASS: one-class-SVM 394 | EPSILON_SVR: epsilon-SVM regression 395 | NU_SVR: nu-SVM regression 396 | 397 | kernel_type can be one of LINEAR, POLY, RBF, SIGMOID. 398 | 399 | LINEAR: u'*v 400 | POLY: (gamma*u'*v + coef0)^degree 401 | RBF: exp(-gamma*|u-v|^2) 402 | SIGMOID: tanh(gamma*u'*v + coef0) 403 | PRECOMPUTED: kernel values in training_set_file 404 | 405 | cache_size is the size of the kernel cache, specified in megabytes. 406 | C is the cost of constraints violation. 407 | eps is the stopping criterion. (we usually use 0.00001 in nu-SVC, 408 | 0.001 in others). nu is the parameter in nu-SVM, nu-SVR, and 409 | one-class-SVM. p is the epsilon in epsilon-insensitive loss function 410 | of epsilon-SVM regression. shrinking = 1 means shrinking is conducted; 411 | = 0 otherwise. probability = 1 means model with probability 412 | information is obtained; = 0 otherwise. 413 | 414 | nr_weight, weight_label, and weight are used to change the penalty 415 | for some classes (If the weight for a class is not changed, it is 416 | set to 1). This is useful for training classifier using unbalanced 417 | input data or with asymmetric misclassification cost. 418 | 419 | nr_weight is the number of elements in the array weight_label and 420 | weight. Each weight[i] corresponds to weight_label[i], meaning that 421 | the penalty of class weight_label[i] is scaled by a factor of weight[i]. 422 | 423 | If you do not want to change penalty for any of the classes, 424 | just set nr_weight to 0. 425 | 426 | *NOTE* Because svm_model contains pointers to svm_problem, you can 427 | not free the memory used by svm_problem if you are still using the 428 | svm_model produced by svm_train(). 429 | 430 | *NOTE* To avoid wrong parameters, svm_check_parameter() should be 431 | called before svm_train(). 432 | 433 | struct svm_model stores the model obtained from the training procedure. 434 | It is not recommended to directly access entries in this structure. 435 | Programmers should use the interface functions to get the values. 436 | 437 | struct svm_model 438 | { 439 | struct svm_parameter param; /* parameter */ 440 | int nr_class; /* number of classes, = 2 in regression/one class svm */ 441 | int l; /* total #SV */ 442 | struct svm_node **SV; /* SVs (SV[l]) */ 443 | double **sv_coef; /* coefficients for SVs in decision functions (sv_coef[k-1][l]) */ 444 | double *rho; /* constants in decision functions (rho[k*(k-1)/2]) */ 445 | double *probA; /* pairwise probability information */ 446 | double *probB; 447 | 448 | /* for classification only */ 449 | 450 | int *label; /* label of each class (label[k]) */ 451 | int *nSV; /* number of SVs for each class (nSV[k]) */ 452 | /* nSV[0] + nSV[1] + ... + nSV[k-1] = l */ 453 | /* XXX */ 454 | int free_sv; /* 1 if svm_model is created by svm_load_model*/ 455 | /* 0 if svm_model is created by svm_train */ 456 | }; 457 | 458 | param describes the parameters used to obtain the model. 459 | 460 | nr_class is the number of classes. It is 2 for regression and one-class SVM. 461 | 462 | l is the number of support vectors. SV and sv_coef are support 463 | vectors and the corresponding coefficients, respectively. Assume there are 464 | k classes. For data in class j, the corresponding sv_coef includes (k-1) y*alpha vectors, 465 | where alpha's are solutions of the following two class problems: 466 | 1 vs j, 2 vs j, ..., j-1 vs j, j vs j+1, j vs j+2, ..., j vs k 467 | and y=1 for the first j-1 vectors, while y=-1 for the remaining k-j 468 | vectors. For example, if there are 4 classes, sv_coef and SV are like: 469 | 470 | +-+-+-+--------------------+ 471 | |1|1|1| | 472 | |v|v|v| SVs from class 1 | 473 | |2|3|4| | 474 | +-+-+-+--------------------+ 475 | |1|2|2| | 476 | |v|v|v| SVs from class 2 | 477 | |2|3|4| | 478 | +-+-+-+--------------------+ 479 | |1|2|3| | 480 | |v|v|v| SVs from class 3 | 481 | |3|3|4| | 482 | +-+-+-+--------------------+ 483 | |1|2|3| | 484 | |v|v|v| SVs from class 4 | 485 | |4|4|4| | 486 | +-+-+-+--------------------+ 487 | 488 | See svm_train() for an example of assigning values to sv_coef. 489 | 490 | rho is the bias term (-b). probA and probB are parameters used in 491 | probability outputs. If there are k classes, there are k*(k-1)/2 492 | binary problems as well as rho, probA, and probB values. They are 493 | aligned in the order of binary problems: 494 | 1 vs 2, 1 vs 3, ..., 1 vs k, 2 vs 3, ..., 2 vs k, ..., k-1 vs k. 495 | 496 | label contains labels in the training data. 497 | 498 | nSV is the number of support vectors in each class. 499 | 500 | free_sv is a flag used to determine whether the space of SV should 501 | be released in free_model_content(struct svm_model*) and 502 | free_and_destroy_model(struct svm_model**). If the model is 503 | generated by svm_train(), then SV points to data in svm_problem 504 | and should not be removed. For example, free_sv is 0 if svm_model 505 | is created by svm_train, but is 0 if created by svm_load_model. 506 | 507 | - Function: double svm_predict(const struct svm_model *model, 508 | const struct svm_node *x); 509 | 510 | This function does classification or regression on a test vector x 511 | given a model. 512 | 513 | For a classification model, the predicted class for x is returned. 514 | For a regression model, the function value of x calculated using 515 | the model is returned. For an one-class model, +1 or -1 is 516 | returned. 517 | 518 | - Function: void svm_cross_validation(const struct svm_problem *prob, 519 | const struct svm_parameter *param, int nr_fold, double *target); 520 | 521 | This function conducts cross validation. Data are separated to 522 | nr_fold folds. Under given parameters, sequentially each fold is 523 | validated using the model from training the remaining. Predicted 524 | labels (of all prob's instances) in the validation process are 525 | stored in the array called target. 526 | 527 | The format of svm_prob is same as that for svm_train(). 528 | 529 | - Function: int svm_get_svm_type(const struct svm_model *model); 530 | 531 | This function gives svm_type of the model. Possible values of 532 | svm_type are defined in svm.h. 533 | 534 | - Function: int svm_get_nr_class(const svm_model *model); 535 | 536 | For a classification model, this function gives the number of 537 | classes. For a regression or an one-class model, 2 is returned. 538 | 539 | - Function: void svm_get_labels(const svm_model *model, int* label) 540 | 541 | For a classification model, this function outputs the name of 542 | labels into an array called label. For regression and one-class 543 | models, label is unchanged. 544 | 545 | - Function: double svm_get_svr_probability(const struct svm_model *model); 546 | 547 | For a regression model with probability information, this function 548 | outputs a value sigma > 0. For test data, we consider the 549 | probability model: target value = predicted value + z, z: Laplace 550 | distribution e^(-|z|/sigma)/(2sigma) 551 | 552 | If the model is not for svr or does not contain required 553 | information, 0 is returned. 554 | 555 | - Function: double svm_predict_values(const svm_model *model, 556 | const svm_node *x, double* dec_values) 557 | 558 | This function gives decision values on a test vector x given a 559 | model, and return the predicted label (classification) or 560 | the function value (regression). 561 | 562 | For a classification model with nr_class classes, this function 563 | gives nr_class*(nr_class-1)/2 decision values in the array 564 | dec_values, where nr_class can be obtained from the function 565 | svm_get_nr_class. The order is label[0] vs. label[1], ..., 566 | label[0] vs. label[nr_class-1], label[1] vs. label[2], ..., 567 | label[nr_class-2] vs. label[nr_class-1], where label can be 568 | obtained from the function svm_get_labels. The returned value is 569 | the predicted class for x. Note that when nr_class = 1, this 570 | function does not give any decision value. 571 | 572 | For a regression model, dec_values[0] and the returned value are 573 | both the function value of x calculated using the model. For a 574 | one-class model, dec_values[0] is the decision value of x, while 575 | the returned value is +1/-1. 576 | 577 | - Function: double svm_predict_probability(const struct svm_model *model, 578 | const struct svm_node *x, double* prob_estimates); 579 | 580 | This function does classification or regression on a test vector x 581 | given a model with probability information. 582 | 583 | For a classification model with probability information, this 584 | function gives nr_class probability estimates in the array 585 | prob_estimates. nr_class can be obtained from the function 586 | svm_get_nr_class. The class with the highest probability is 587 | returned. For regression/one-class SVM, the array prob_estimates 588 | is unchanged and the returned value is the same as that of 589 | svm_predict. 590 | 591 | - Function: const char *svm_check_parameter(const struct svm_problem *prob, 592 | const struct svm_parameter *param); 593 | 594 | This function checks whether the parameters are within the feasible 595 | range of the problem. This function should be called before calling 596 | svm_train() and svm_cross_validation(). It returns NULL if the 597 | parameters are feasible, otherwise an error message is returned. 598 | 599 | - Function: int svm_check_probability_model(const struct svm_model *model); 600 | 601 | This function checks whether the model contains required 602 | information to do probability estimates. If so, it returns 603 | +1. Otherwise, 0 is returned. This function should be called 604 | before calling svm_get_svr_probability and 605 | svm_predict_probability. 606 | 607 | - Function: int svm_save_model(const char *model_file_name, 608 | const struct svm_model *model); 609 | 610 | This function saves a model to a file; returns 0 on success, or -1 611 | if an error occurs. 612 | 613 | - Function: struct svm_model *svm_load_model(const char *model_file_name); 614 | 615 | This function returns a pointer to the model read from the file, 616 | or a null pointer if the model could not be loaded. 617 | 618 | - Function: void svm_free_model_content(struct svm_model *model_ptr); 619 | 620 | This function frees the memory used by the entries in a model structure. 621 | 622 | - Function: void svm_free_and_destroy_model(struct svm_model **model_ptr_ptr); 623 | 624 | This function frees the memory used by a model and destroys the model 625 | structure. It is equivalent to svm_destroy_model, which 626 | is deprecated after version 3.0. 627 | 628 | - Function: void svm_destroy_param(struct svm_parameter *param); 629 | 630 | This function frees the memory used by a parameter set. 631 | 632 | - Function: void svm_set_print_string_function(void (*print_func)(const char *)); 633 | 634 | Users can specify their output format by a function. Use 635 | svm_set_print_string_function(NULL); 636 | for default printing to stdout. 637 | 638 | Java Version 639 | ============ 640 | 641 | The pre-compiled java class archive `libsvm.jar' and its source files are 642 | in the java directory. To run the programs, use 643 | 644 | java -classpath libsvm.jar svm_train 645 | java -classpath libsvm.jar svm_predict 646 | java -classpath libsvm.jar svm_toy 647 | java -classpath libsvm.jar svm_scale 648 | 649 | Note that you need Java 1.5 (5.0) or above to run it. 650 | 651 | You may need to add Java runtime library (like classes.zip) to the classpath. 652 | You may need to increase maximum Java heap size. 653 | 654 | Library usages are similar to the C version. These functions are available: 655 | 656 | public class svm { 657 | public static final int LIBSVM_VERSION=312; 658 | public static svm_model svm_train(svm_problem prob, svm_parameter param); 659 | public static void svm_cross_validation(svm_problem prob, svm_parameter param, int nr_fold, double[] target); 660 | public static int svm_get_svm_type(svm_model model); 661 | public static int svm_get_nr_class(svm_model model); 662 | public static void svm_get_labels(svm_model model, int[] label); 663 | public static double svm_get_svr_probability(svm_model model); 664 | public static double svm_predict_values(svm_model model, svm_node[] x, double[] dec_values); 665 | public static double svm_predict(svm_model model, svm_node[] x); 666 | public static double svm_predict_probability(svm_model model, svm_node[] x, double[] prob_estimates); 667 | public static void svm_save_model(String model_file_name, svm_model model) throws IOException 668 | public static svm_model svm_load_model(String model_file_name) throws IOException 669 | public static String svm_check_parameter(svm_problem prob, svm_parameter param); 670 | public static int svm_check_probability_model(svm_model model); 671 | public static void svm_set_print_string_function(svm_print_interface print_func); 672 | } 673 | 674 | The library is in the "libsvm" package. 675 | Note that in Java version, svm_node[] is not ended with a node whose index = -1. 676 | 677 | Users can specify their output format by 678 | 679 | your_print_func = new svm_print_interface() 680 | { 681 | public void print(String s) 682 | { 683 | // your own format 684 | } 685 | }; 686 | svm.svm_set_print_string_function(your_print_func); 687 | 688 | Building Windows Binaries 689 | ========================= 690 | 691 | Windows binaries are in the directory `windows'. To build them via 692 | Visual C++, use the following steps: 693 | 694 | 1. Open a DOS command box (or Visual Studio Command Prompt) and change 695 | to libsvm directory. If environment variables of VC++ have not been 696 | set, type 697 | 698 | "C:\Program Files\Microsoft Visual Studio 10.0\VC\bin\vcvars32.bat" 699 | 700 | You may have to modify the above command according which version of 701 | VC++ or where it is installed. 702 | 703 | 2. Type 704 | 705 | nmake -f Makefile.win clean all 706 | 707 | 3. (optional) To build shared library libsvm.dll, type 708 | 709 | nmake -f Makefile.win lib 710 | 711 | Another way is to build them from Visual C++ environment. See details 712 | in libsvm FAQ. 713 | 714 | - Additional Tools: Sub-sampling, Parameter Selection, Format checking, etc. 715 | ============================================================================ 716 | 717 | See the README file in the tools directory. 718 | 719 | MATLAB/OCTAVE Interface 720 | ======================= 721 | 722 | Please check the file README in the directory `matlab'. 723 | 724 | Python Interface 725 | ================ 726 | 727 | See the README file in python directory. 728 | 729 | Additional Information 730 | ====================== 731 | 732 | If you find LIBSVM helpful, please cite it as 733 | 734 | Chih-Chung Chang and Chih-Jen Lin, LIBSVM : a library for support 735 | vector machines. ACM Transactions on Intelligent Systems and 736 | Technology, 2:27:1--27:27, 2011. Software available at 737 | http://www.csie.ntu.edu.tw/~cjlin/libsvm 738 | 739 | LIBSVM implementation document is available at 740 | http://www.csie.ntu.edu.tw/~cjlin/papers/libsvm.pdf 741 | 742 | For any questions and comments, please email cjlin@csie.ntu.edu.tw 743 | 744 | Acknowledgments: 745 | This work was supported in part by the National Science 746 | Council of Taiwan via the grant NSC 89-2213-E-002-013. 747 | The authors thank their group members and users 748 | for many helpful discussions and comments. They are listed in 749 | http://www.csie.ntu.edu.tw/~cjlin/libsvm/acknowledgements 750 | 751 | -------------------------------------------------------------------------------- /nbproject/build-impl.xml: -------------------------------------------------------------------------------- 1 | 2 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | 76 | 77 | 78 | 79 | 80 | 81 | 82 | 83 | 84 | 85 | 86 | 87 | 88 | 89 | 90 | 91 | 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 | 105 | 106 | 107 | 108 | 109 | 110 | 111 | 112 | 113 | 114 | 115 | 116 | 117 | 118 | 119 | 120 | 121 | 122 | 123 | 124 | 125 | 126 | 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | 139 | 140 | 141 | 142 | 143 | 144 | 145 | 146 | 147 | 148 | 149 | 150 | 151 | 152 | 153 | 154 | 155 | 156 | 157 | 158 | 159 | 160 | 161 | 162 | 163 | 164 | 165 | 166 | 167 | 168 | 169 | 170 | 171 | 172 | 173 | 174 | 175 | 176 | 177 | 178 | 179 | 180 | 181 | 182 | 183 | 184 | 185 | 186 | 187 | 188 | 189 | 190 | 191 | 192 | 193 | 194 | 195 | 196 | 197 | 198 | 199 | 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | Must set src.dir 209 | Must set test.src.dir 210 | Must set build.dir 211 | Must set dist.dir 212 | Must set build.classes.dir 213 | Must set dist.javadoc.dir 214 | Must set build.test.classes.dir 215 | Must set build.test.results.dir 216 | Must set build.classes.excludes 217 | Must set dist.jar 218 | 219 | 220 | 221 | 222 | 223 | 224 | 225 | 226 | 227 | 228 | 229 | 230 | 231 | 232 | 233 | 234 | 235 | 236 | 237 | 238 | 239 | 240 | 241 | 242 | 243 | 244 | 245 | 246 | 247 | 248 | 249 | 250 | 251 | 252 | 253 | 254 | 255 | 256 | 257 | 258 | 259 | 260 | 261 | 262 | 263 | 264 | 265 | 266 | 267 | 268 | 269 | 270 | 271 | 272 | 273 | 274 | 275 | 276 | 277 | 278 | 279 | 280 | 281 | 282 | 283 | 284 | 285 | 286 | 287 | 288 | 289 | 290 | 291 | 292 | 293 | 294 | 295 | 296 | 297 | 298 | 299 | 300 | 301 | 302 | 303 | 304 | 305 | 306 | 307 | 308 | 309 | 310 | 311 | 312 | 313 | 314 | 315 | 316 | Must set javac.includes 317 | 318 | 319 | 320 | 321 | 322 | 323 | 324 | 325 | 326 | 327 | 328 | 329 | 330 | 331 | 332 | 333 | 334 | 335 | 336 | 337 | 338 | 339 | 340 | 341 | 342 | 343 | 344 | 345 | 346 | 347 | 348 | 349 | 350 | 351 | 352 | 353 | 354 | 355 | 356 | 357 | 358 | 359 | 360 | 361 | 362 | 363 | 364 | 365 | 366 | 367 | 368 | 369 | 370 | 371 | 372 | 373 | 374 | 375 | 376 | 377 | 378 | 379 | 380 | 381 | 382 | 383 | 384 | 385 | 386 | 387 | 388 | 389 | 390 | 391 | 392 | 393 | 394 | 395 | 396 | 397 | 398 | 399 | 400 | 401 | 402 | 403 | 404 | Must set JVM to use for profiling in profiler.info.jvm 405 | Must set profiler agent JVM arguments in profiler.info.jvmargs.agent 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 419 | 420 | 421 | 422 | 423 | 424 | 425 | 426 | 427 | 428 | 429 | 430 | 431 | 432 | 433 | 434 | 435 | 436 | 437 | 438 | 439 | 440 | 441 | 442 | 443 | 444 | 445 | 446 | 447 | 448 | 449 | 450 | 451 | 452 | 453 | 454 | 455 | 456 | 457 | 458 | 459 | 460 | 461 | 462 | 463 | 464 | 465 | 466 | 467 | 468 | 469 | 470 | 471 | 472 | 473 | 474 | 475 | 476 | 477 | 478 | 479 | 480 | 481 | 482 | 483 | 484 | 485 | 486 | 487 | 488 | 489 | 490 | 491 | 492 | 493 | 494 | 495 | 496 | 497 | 498 | 499 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 509 | 510 | 511 | 512 | 513 | 514 | 515 | 516 | 517 | 518 | 519 | 520 | 521 | 522 | 523 | 524 | 525 | 526 | 527 | 528 | 529 | 530 | 531 | 532 | 533 | 534 | 535 | 536 | 537 | 538 | 539 | 540 | 541 | 542 | 543 | 544 | 545 | 546 | 547 | 548 | 549 | 550 | 551 | 552 | 553 | 554 | 555 | 556 | 557 | 558 | 559 | 564 | 565 | 566 | 567 | 568 | 569 | 570 | 571 | 572 | 573 | 574 | 575 | 576 | 577 | 578 | 579 | 580 | 581 | 582 | 583 | 584 | 585 | 586 | 587 | 588 | 589 | 590 | 591 | 592 | 593 | 594 | 595 | 596 | 597 | 598 | 599 | 600 | 601 | 602 | 603 | 604 | 605 | 606 | 607 | 608 | 609 | 610 | 611 | 612 | 613 | 614 | 615 | 616 | 617 | 618 | 619 | 620 | 621 | 622 | 623 | 624 | Must select some files in the IDE or set javac.includes 625 | 626 | 627 | 628 | 629 | 630 | 631 | 632 | 633 | 638 | 639 | 640 | 641 | 642 | 643 | 644 | 645 | 646 | 647 | 648 | 649 | 650 | 651 | 652 | 653 | 654 | 655 | 656 | 657 | 658 | To run this application from the command line without Ant, try: 659 | 660 | 661 | 662 | 663 | 664 | 665 | java -cp "${run.classpath.with.dist.jar}" ${main.class} 666 | 667 | 668 | 669 | 670 | 671 | 672 | 673 | 674 | 675 | 676 | 677 | 678 | 679 | 680 | 681 | 682 | 683 | 684 | 685 | 686 | 687 | 688 | 689 | 690 | To run this application from the command line without Ant, try: 691 | 692 | java -jar "${dist.jar.resolved}" 693 | 694 | 695 | 696 | 697 | 698 | 699 | 700 | 701 | 702 | 703 | 704 | 705 | 710 | 711 | 712 | 713 | 714 | 715 | 716 | 717 | 718 | 719 | 720 | 721 | Must select one file in the IDE or set run.class 722 | 723 | 724 | 725 | Must select one file in the IDE or set run.class 726 | 727 | 728 | 733 | 734 | 735 | 736 | 737 | 738 | 739 | 740 | 741 | 742 | 743 | 744 | 745 | 746 | 747 | 748 | 749 | 750 | 751 | 752 | Must select one file in the IDE or set debug.class 753 | 754 | 755 | 756 | 757 | Must select one file in the IDE or set debug.class 758 | 759 | 760 | 761 | 762 | Must set fix.includes 763 | 764 | 765 | 766 | 767 | 768 | 769 | 774 | 775 | 776 | 777 | 778 | 779 | 780 | 781 | 782 | 783 | Must select one file in the IDE or set profile.class 784 | 785 | 786 | 787 | 788 | 789 | 790 | 791 | 796 | 797 | 798 | 799 | 800 | 801 | 802 | 803 | 804 | 805 | 806 | 807 | 808 | 813 | 814 | 815 | 816 | 817 | 818 | 819 | 820 | 821 | 822 | 823 | 824 | 825 | 826 | 827 | 828 | 829 | 830 | 831 | 832 | 833 | 834 | 835 | 840 | 841 | 842 | 843 | 844 | 845 | 846 | 847 | 848 | 849 | 850 | 851 | 852 | 853 | 854 | 855 | 856 | 857 | 858 | 859 | 860 | 861 | 862 | 863 | 864 | 865 | 866 | 867 | 872 | 873 | 874 | 875 | 876 | 877 | 878 | 879 | 880 | 881 | 882 | 883 | 884 | 885 | 886 | 887 | 888 | 889 | 890 | 891 | 892 | 893 | 894 | 895 | 896 | 897 | 898 | Must select some files in the IDE or set javac.includes 899 | 900 | 901 | 902 | 903 | 904 | 905 | 906 | 907 | 908 | 909 | 910 | 915 | 916 | 917 | 918 | 919 | 920 | 921 | 922 | Some tests failed; see details above. 923 | 924 | 925 | 926 | 927 | 928 | 929 | 930 | 931 | Must select some files in the IDE or set test.includes 932 | 933 | 934 | 935 | Some tests failed; see details above. 936 | 937 | 938 | 943 | 944 | Must select one file in the IDE or set test.class 945 | 946 | 947 | 948 | 949 | 950 | 951 | 952 | 953 | 954 | 955 | 956 | 957 | 958 | 959 | 960 | 961 | 962 | 963 | 964 | 965 | 966 | 967 | 968 | 969 | 974 | 975 | Must select one file in the IDE or set applet.url 976 | 977 | 978 | 979 | 980 | 981 | 982 | 987 | 988 | Must select one file in the IDE or set applet.url 989 | 990 | 991 | 992 | 993 | 994 | 995 | 996 | 1001 | 1002 | 1003 | 1004 | 1005 | 1006 | 1007 | 1008 | 1009 | 1010 | 1011 | 1012 | 1013 | 1014 | 1015 | 1016 | 1017 | 1018 | 1019 | 1020 | 1021 | 1022 | 1023 | 1024 | 1025 | 1026 | 1027 | 1028 | 1029 | 1030 | 1031 | 1032 | 1033 | 1034 | 1035 | 1036 | 1037 | 1038 | 1039 | 1040 | 1041 | 1042 | 1043 | --------------------------------------------------------------------------------