libsvm java调用

1. 调用doc

public class Libsvm {

    static Libsvm libsvm;

    private Libsvm() {

    }

    public static Libsvm getInstance() {
        if (libsvm == null) {
            libsvm = new Libsvm();
        }
        return libsvm;
    }

    public void train(String trainFile, String modelFile) {
        String trainCmd = "d:/libsvm-3.17/windows/svm-train -t 0 -b 1 " + trainFile + " " + modelFile;
        try {
            Runtime.getRuntime().exec(trainCmd);
            Thread.sleep(15000);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void predict(String predictFile, String modelFile, String ouputFile) {
        String predictCmd = "d:/libsvm-3.17/windows/svm-predict -b 1 " + predictFile + " " + modelFile
                + " " + ouputFile;
        try {
            Runtime.getRuntime().exec(predictCmd);
            Thread.sleep(500);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

java源码应用

训练

public void libsvm_train(String options, String trainfile, String modelfile) {
        String[] args = { options, trainfile, modelfile}; Svm_train.main(args); }

预测

public void libsvm_predict(String predict, String model, String outfile ) {
        String[] args = { predict, model, outfile }; Svm_predict.main(args); }

Svm_predict.java

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.util.StringTokenizer;

import libsvm.svm;
import libsvm.svm_model;
import libsvm.svm_node;
import libsvm.svm_parameter;
import libsvm.svm_print_interface;

public class Svm_predict {
    private static svm_print_interface svm_print_null = new svm_print_interface() {
        public void print(String s) {
        }
    };

    private static svm_print_interface svm_print_stdout = new svm_print_interface() {
        public void print(String s) {
            System.out.print(s);
        }
    };

    private static svm_print_interface svm_print_string = svm_print_stdout;

    static void info(String s) {
        svm_print_string.print(s);
    }

    private static double atof(String s) {
        return Double.valueOf(s).doubleValue();
    }

    private static int atoi(String s) {
        return Integer.parseInt(s);
    }

    private static void predict(BufferedReader input, DataOutputStream output,
            svm_model model, int predict_probability) throws IOException {
        int correct = 0;
        int total = 0;
        double error = 0;
        double sumv = 0, sumy = 0, sumvv = 0, sumyy = 0, sumvy = 0;

        int svm_type = svm.svm_get_svm_type(model);
        int nr_class = svm.svm_get_nr_class(model);
        double[] prob_estimates = null;

        if (predict_probability == 1) {
            if (svm_type == svm_parameter.EPSILON_SVR
                    || svm_type == svm_parameter.NU_SVR) {
                Svm_predict
                        .info("Prob. model for test data: target value = predicted value + z,\nz: Laplace distribution e^(-|z|/sigma)/(2sigma),sigma="
                                + svm.svm_get_svr_probability(model) + "\n");
            } else {
                int[] labels = new int[nr_class];
                svm.svm_get_labels(model, labels);
                prob_estimates = new double[nr_class];
                output.writeBytes("labels");
                for (int j = 0; j < nr_class; j++)
                    output.writeBytes(" " + labels[j]);
                output.writeBytes("\n");
            }
        }
        while (true) {
            String line = input.readLine();
            if (line == null)
                break;

            StringTokenizer st = new StringTokenizer(line, " \t\n\r\f:");

            double target = atof(st.nextToken());
            int m = st.countTokens() / 2;
            svm_node[] x = new svm_node[m];
            for (int j = 0; j < m; j++) {
                x[j] = new svm_node();
                x[j].index = atoi(st.nextToken());
                x[j].value = atof(st.nextToken());
            }

            double v;
            if (predict_probability == 1
                    && (svm_type == svm_parameter.C_SVC || svm_type == svm_parameter.NU_SVC)) {
                v = svm.svm_predict_probability(model, x, prob_estimates);
                output.writeBytes(v + " ");
                for (int j = 0; j < nr_class; j++)
                    output.writeBytes(prob_estimates[j] + " ");
                output.writeBytes("\n");
            } else {
                v = svm.svm_predict(model, x);
                output.writeBytes(v + "\n");
            }

            if (v == target)
                ++correct;
            error += (v - target) * (v - target);
            sumv += v;
            sumy += target;
            sumvv += v * v;
            sumyy += target * target;
            sumvy += v * target;
            ++total;
        }
        if (svm_type == svm_parameter.EPSILON_SVR
                || svm_type == svm_parameter.NU_SVR) {
            Svm_predict.info("Mean squared error = " + error / total
                    + " (regression)\n");
            Svm_predict.info("Squared correlation coefficient = "
                    + ((total * sumvy - sumv * sumy) * (total * sumvy - sumv
                            * sumy))
                    / ((total * sumvv - sumv * sumv) * (total * sumyy - sumy
                            * sumy)) + " (regression)\n");
        } else
            Svm_predict.info("Accuracy = " + (double) correct / total * 100
                    + "% (" + correct + "/" + total + ") (classification)\n");
    }

    private static void exit_with_help() {
        System.err
                .print("usage: svm_predict [options] test_file model_file output_file\n"
                        + "options:\n"
                        + "-b probability_estimates: whether to predict probability estimates, 0 or 1 (default 0); one-class SVM not supported yet\n"
                        + "-q : quiet mode (no outputs)\n");
        System.exit(1);
    }

    public static void main(String argv[]) throws IOException {
        int i, predict_probability = 1; //测试时开启label概率计算
        svm_print_string = svm_print_stdout;

        // parse options
        for (i = 0; i < argv.length; i++) {
            if (argv[i].charAt(0) != '-')
                break;
            ++i;
            switch (argv[i - 1].charAt(1)) {
            case 'b':
                predict_probability = atoi(argv[i]);
                break;
            case 'q':
                svm_print_string = svm_print_null;
                i--;
                break;
            default:
                System.err.print("Unknown option: " + argv[i - 1] + "\n");
                exit_with_help();
            }
        }
        if (i >= argv.length - 2)
            exit_with_help();
        try {
            BufferedReader input = new BufferedReader(new FileReader(argv[i]));
            DataOutputStream output = new DataOutputStream(
                    new BufferedOutputStream(new FileOutputStream(argv[i + 2])));
            svm_model model = svm.svm_load_model(argv[i + 1]);
            if (predict_probability == 1) {
                if (svm.svm_check_probability_model(model) == 0) {
                    System.err
                            .print("Model does not support probabiliy estimates\n");
                    System.exit(1);
                }
            } else {
                if (svm.svm_check_probability_model(model) != 0) {
                    Svm_predict
                            .info("Model supports probability estimates, but disabled in prediction.\n");
                }
            }
            predict(input, output, model, predict_probability);
            input.close();
            output.close();
        } catch (FileNotFoundException e) {
            exit_with_help();
        } catch (ArrayIndexOutOfBoundsException e) {
            exit_with_help();
        }
    }
}

Svm_scale.java

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Formatter;
import java.util.StringTokenizer;

class Svm_scale {
    private String line = null;
    private double lower = -1.0;
    private double upper = 1.0;
    private double y_lower;
    private double y_upper;
    private boolean y_scaling = false;
    private double[] feature_max;
    private double[] feature_min;
    private double y_max = -Double.MAX_VALUE;
    private double y_min = Double.MAX_VALUE;
    private int max_index;
    private long num_nonzeros = 0;
    private long new_num_nonzeros = 0;

    private static void exit_with_help() {
        System.out
                .print("Usage: svm-scale [options] data_filename\n"
                        + "options:\n"
                        + "-l lower : x scaling lower limit (default -1)\n"
                        + "-u upper : x scaling upper limit (default +1)\n"
                        + "-y y_lower y_upper : y scaling limits (default: no y scaling)\n"
                        + "-s save_filename : save scaling parameters to save_filename\n"
                        + "-r restore_filename : restore scaling parameters from restore_filename\n");
        System.exit(1);
    }

    private BufferedReader rewind(BufferedReader fp, String filename)
            throws IOException {
        fp.close();
        return new BufferedReader(new FileReader(filename));
    }

    private void output_target(double value) {
        if (y_scaling) {
            if (value == y_min)
                value = y_lower;
            else if (value == y_max)
                value = y_upper;
            else
                value = y_lower + (y_upper - y_lower) * (value - y_min)
                        / (y_max - y_min);
        }

        System.out.print(value + " ");
    }

    private void output(int index, double value) {
        /* skip single-valued attribute */
        if (feature_max[index] == feature_min[index])
            return;

        if (value == feature_min[index])
            value = lower;
        else if (value == feature_max[index])
            value = upper;
        else
            value = lower + (upper - lower) * (value - feature_min[index])
                    / (feature_max[index] - feature_min[index]);

        if (value != 0) {
            System.out.print(index + ":" + value + " ");
            new_num_nonzeros++;
        }
    }

    private String readline(BufferedReader fp) throws IOException {
        line = fp.readLine();
        return line;
    }

    @SuppressWarnings({ "unused", "resource" })
    private void run(String[] argv) throws IOException {
        int i, index;
        BufferedReader fp = null, fp_restore = null;
        String save_filename = null;
        String restore_filename = null;
        String data_filename = null;

        for (i = 0; i < argv.length; i++) {
            if (argv[i].charAt(0) != '-')
                break;
            ++i;
            switch (argv[i - 1].charAt(1)) {
            case 'l':
                lower = Double.parseDouble(argv[i]);
                break;
            case 'u':
                upper = Double.parseDouble(argv[i]);
                break;
            case 'y':
                y_lower = Double.parseDouble(argv[i]);
                ++i;
                y_upper = Double.parseDouble(argv[i]);
                y_scaling = true;
                break;
            case 's':
                save_filename = argv[i];
                break;
            case 'r':
                restore_filename = argv[i];
                break;
            default:
                System.err.println("unknown option");
                exit_with_help();
            }
        }

        if (!(upper > lower) || (y_scaling && !(y_upper > y_lower))) {
            System.err.println("inconsistent lower/upper specification");
            System.exit(1);
        }
        if (restore_filename != null && save_filename != null) {
            System.err.println("cannot use -r and -s simultaneously");
            System.exit(1);
        }

        if (argv.length != i + 1)
            exit_with_help();

        data_filename = argv[i];
        try {
            fp = new BufferedReader(new FileReader(data_filename));
        } catch (Exception e) {
            System.err.println("can't open file " + data_filename);
            System.exit(1);
        }

        /* assumption: min index of attributes is 1 */
        /* pass 1: find out max index of attributes */
        max_index = 0;

        if (restore_filename != null) {
            int idx, c;

            try {
                fp_restore = new BufferedReader(
                        new FileReader(restore_filename));
            } catch (Exception e) {
                System.err.println("can't open file " + restore_filename);
                System.exit(1);
            }
            if ((c = fp_restore.read()) == 'y') {
                fp_restore.readLine();
                fp_restore.readLine();
                fp_restore.readLine();
            }
            fp_restore.readLine();
            fp_restore.readLine();

            String restore_line = null;
            while ((restore_line = fp_restore.readLine()) != null) {
                StringTokenizer st2 = new StringTokenizer(restore_line);
                idx = Integer.parseInt(st2.nextToken());
                max_index = Math.max(max_index, idx);
            }
            fp_restore = rewind(fp_restore, restore_filename);
        }

        while (readline(fp) != null) {
            StringTokenizer st = new StringTokenizer(line, " \t\n\r\f:");
            st.nextToken();
            while (st.hasMoreTokens()) {
                index = Integer.parseInt(st.nextToken());
                max_index = Math.max(max_index, index);
                st.nextToken();
                num_nonzeros++;
            }
        }

        try {
            feature_max = new double[(max_index + 1)];
            feature_min = new double[(max_index + 1)];
        } catch (OutOfMemoryError e) {
            System.err.println("can't allocate enough memory");
            System.exit(1);
        }

        for (i = 0; i <= max_index; i++) {
            feature_max[i] = -Double.MAX_VALUE;
            feature_min[i] = Double.MAX_VALUE;
        }

        fp = rewind(fp, data_filename);

        /* pass 2: find out min/max value */
        while (readline(fp) != null) {
            int next_index = 1;
            double target;
            double value;

            StringTokenizer st = new StringTokenizer(line, " \t\n\r\f:");
            target = Double.parseDouble(st.nextToken());
            y_max = Math.max(y_max, target);
            y_min = Math.min(y_min, target);

            while (st.hasMoreTokens()) {
                index = Integer.parseInt(st.nextToken());
                value = Double.parseDouble(st.nextToken());

                for (i = next_index; i < index; i++) {
                    feature_max[i] = Math.max(feature_max[i], 0);
                    feature_min[i] = Math.min(feature_min[i], 0);
                }

                feature_max[index] = Math.max(feature_max[index], value);
                feature_min[index] = Math.min(feature_min[index], value);
                next_index = index + 1;
            }

            for (i = next_index; i <= max_index; i++) {
                feature_max[i] = Math.max(feature_max[i], 0);
                feature_min[i] = Math.min(feature_min[i], 0);
            }
        }

        fp = rewind(fp, data_filename);

        /* pass 2.5: save/restore feature_min/feature_max */
        if (restore_filename != null) {
            // fp_restore rewinded in finding max_index
            int idx, c;
            double fmin, fmax;

            fp_restore.mark(2); // for reset
            if ((c = fp_restore.read()) == 'y') {
                fp_restore.readLine(); // pass the '\n' after 'y'
                StringTokenizer st = new StringTokenizer(fp_restore.readLine());
                y_lower = Double.parseDouble(st.nextToken());
                y_upper = Double.parseDouble(st.nextToken());
                st = new StringTokenizer(fp_restore.readLine());
                y_min = Double.parseDouble(st.nextToken());
                y_max = Double.parseDouble(st.nextToken());
                y_scaling = true;
            } else
                fp_restore.reset();

            if (fp_restore.read() == 'x') {
                fp_restore.readLine(); // pass the '\n' after 'x'
                StringTokenizer st = new StringTokenizer(fp_restore.readLine());
                lower = Double.parseDouble(st.nextToken());
                upper = Double.parseDouble(st.nextToken());
                String restore_line = null;
                while ((restore_line = fp_restore.readLine()) != null) {
                    StringTokenizer st2 = new StringTokenizer(restore_line);
                    idx = Integer.parseInt(st2.nextToken());
                    fmin = Double.parseDouble(st2.nextToken());
                    fmax = Double.parseDouble(st2.nextToken());
                    if (idx <= max_index) {
                        feature_min[idx] = fmin;
                        feature_max[idx] = fmax;
                    }
                }
            }
            fp_restore.close();
        }

        if (save_filename != null) {
            Formatter formatter = new Formatter(new StringBuilder());
            BufferedWriter fp_save = null;

            try {
                fp_save = new BufferedWriter(new FileWriter(save_filename));
            } catch (IOException e) {
                System.err.println("can't open file " + save_filename);
                System.exit(1);
            }

            if (y_scaling) {
                formatter.format("y\n");
                formatter.format("%.16g %.16g\n", y_lower, y_upper);
                formatter.format("%.16g %.16g\n", y_min, y_max);
            }
            formatter.format("x\n");
            formatter.format("%.16g %.16g\n", lower, upper);
            for (i = 1; i <= max_index; i++) {
                if (feature_min[i] != feature_max[i])
                    formatter.format("%d %.16g %.16g\n", i, feature_min[i],
                            feature_max[i]);
            }
            fp_save.write(formatter.toString());
            fp_save.close();
        }

        /* pass 3: scale */
        while (readline(fp) != null) {
            int next_index = 1;
            double target;
            double value;

            StringTokenizer st = new StringTokenizer(line, " \t\n\r\f:");
            target = Double.parseDouble(st.nextToken());
            output_target(target);
            while (st.hasMoreElements()) {
                index = Integer.parseInt(st.nextToken());
                value = Double.parseDouble(st.nextToken());
                for (i = next_index; i < index; i++)
                    output(i, 0);
                output(index, value);
                next_index = index + 1;
            }

            for (i = next_index; i <= max_index; i++)
                output(i, 0);
            System.out.print("\n");
        }
        if (new_num_nonzeros > num_nonzeros)
            System.err.print("WARNING: original #nonzeros " + num_nonzeros
                    + "\n" + " new #nonzeros " + new_num_nonzeros
                    + "\n"
                    + "Use -l 0 if many original feature values are zeros\n");

        fp.close();
    }

    public static void main(String argv[]) throws IOException {
        Svm_scale s = new Svm_scale();
        s.run(argv);
    }
}

Svm_train.java

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.StringTokenizer;
import java.util.Vector;

import libsvm.svm;
import libsvm.svm_model;
import libsvm.svm_node;
import libsvm.svm_parameter;
import libsvm.svm_print_interface;
import libsvm.svm_problem;

public class Svm_train {
    private svm_parameter param; // set by parse_command_line
    private svm_problem prob; // set by read_problem
    private svm_model model;
    private String input_file_name; // set by parse_command_line
    private String model_file_name; // set by parse_command_line
    private String error_msg;
    private int cross_validation;
    private int nr_fold;

    private static svm_print_interface svm_print_null = new svm_print_interface() {
        public void print(String s) {
        }
    };

    private static void exit_with_help() {
        System.out
                .print("Usage: svm_train [options] training_set_file [model_file]\n"
                        + "options:\n"
                        + "-s svm_type : set type of SVM (default 0)\n"
                        + " 0 -- C-SVC (multi-class classification)\n"
                        + " 1 -- nu-SVC (multi-class classification)\n"
                        + " 2 -- one-class SVM\n"
                        + " 3 -- epsilon-SVR (regression)\n"
                        + " 4 -- nu-SVR (regression)\n"
                        + "-t kernel_type : set type of kernel function (default 2)\n"
                        + " 0 -- linear: u'*v\n"
                        + " 1 -- polynomial: (gamma*u'*v + coef0)^degree\n"
                        + " 2 -- radial basis function: exp(-gamma*|u-v|^2)\n"
                        + " 3 -- sigmoid: tanh(gamma*u'*v + coef0)\n"
                        + " 4 -- precomputed kernel (kernel values in training_set_file)\n"
                        + "-d degree : set degree in kernel function (default 3)\n"
                        + "-g gamma : set gamma in kernel function (default 1/num_features)\n"
                        + "-r coef0 : set coef0 in kernel function (default 0)\n"
                        + "-c cost : set the parameter C of C-SVC, epsilon-SVR, and nu-SVR (default 1)\n"
                        + "-n nu : set the parameter nu of nu-SVC, one-class SVM, and nu-SVR (default 0.5)\n"
                        + "-p epsilon : set the epsilon in loss function of epsilon-SVR (default 0.1)\n"
                        + "-m cachesize : set cache memory size in MB (default 100)\n"
                        + "-e epsilon : set tolerance of termination criterion (default 0.001)\n"
                        + "-h shrinking : whether to use the shrinking heuristics, 0 or 1 (default 1)\n"
                        + "-b probability_estimates : whether to train a SVC or SVR model for probability estimates, 0 or 1 (default 0)\n"
                        + "-wi weight : set the parameter C of class i to weight*C, for C-SVC (default 1)\n"
                        + "-v n : n-fold cross validation mode\n"
                        + "-q : quiet mode (no outputs)\n");
        System.exit(1);
    }

    private void do_cross_validation() {
        int i;
        int total_correct = 0;
        double total_error = 0;
        double sumv = 0, sumy = 0, sumvv = 0, sumyy = 0, sumvy = 0;
        double[] target = new double[prob.l];

        svm.svm_cross_validation(prob, param, nr_fold, target);
        if (param.svm_type == svm_parameter.EPSILON_SVR
                || param.svm_type == svm_parameter.NU_SVR) {
            for (i = 0; i < prob.l; i++) {
                double y = prob.y[i];
                double v = target[i];
                total_error += (v - y) * (v - y);
                sumv += v;
                sumy += y;
                sumvv += v * v;
                sumyy += y * y;
                sumvy += v * y;
            }
            System.out.print("Cross Validation Mean squared error = "
                    + total_error / prob.l + "\n");
            System.out
                    .print("Cross Validation Squared correlation coefficient = "
                            + ((prob.l * sumvy - sumv * sumy) * (prob.l * sumvy - sumv
                                    * sumy))
                            / ((prob.l * sumvv - sumv * sumv) * (prob.l * sumyy - sumy
                                    * sumy)) + "\n");
        } else {
            for (i = 0; i < prob.l; i++)
                if (target[i] == prob.y[i])
                    ++total_correct;
            System.out.print("Cross Validation Accuracy = " + 100.0
                    * total_correct / prob.l + "%\n");
        }
    }

    private void run(String argv[]) throws IOException {
        parse_command_line(argv);
        read_problem();
        error_msg = svm.svm_check_parameter(prob, param);

        if (error_msg != null) {
            System.err.print("ERROR: " + error_msg + "\n");
            System.exit(1);
        }

        if (cross_validation != 0) {
            do_cross_validation();
        } else {
            model = svm.svm_train(prob, param);
            svm.svm_save_model(model_file_name, model);
        }
    }

    public static void main(String argv[]) throws IOException {
        Svm_train t = new Svm_train();
        t.run(argv);
    }

    private static double atof(String s) {
        double d = Double.valueOf(s).doubleValue();
        if (Double.isNaN(d) || Double.isInfinite(d)) {
            System.err.print("NaN or Infinity in input\n");
            System.exit(1);
        }
        return (d);
    }

    private static int atoi(String s) {
        return Integer.parseInt(s);
    }

    private void parse_command_line(String argv[]) {
        int i;
        svm_print_interface print_func = null; // default printing to stdout

        param = new svm_parameter();
        // default values
        param.svm_type = svm_parameter.C_SVC;
        param.kernel_type = svm_parameter.LINEAR; // 使用线性函数
        param.degree = 3;
        param.gamma = 0; // 1/num_features
        param.coef0 = 0;
        param.nu = 0.5;
        param.cache_size = 100;
        param.C = 1;
        param.eps = 1e-3;
        param.p = 0.1;
        param.shrinking = 1;
        param.probability = 1; // 使用概率值，对每个label进行概率分析
        param.nr_weight = 0;
        param.weight_label = new int[0];
        param.weight = new double[0];
        cross_validation = 0;

        // parse options
        for (i = 0; i < argv.length; i++) {
            if (argv[i].charAt(0) != '-')
                break;
            if (++i >= argv.length)
                exit_with_help();
            switch (argv[i - 1].charAt(1)) {
            case 's':
                param.svm_type = atoi(argv[i]);
                break;
            case 't':
                param.kernel_type = atoi(argv[i]);
                break;
            case 'd':
                param.degree = atoi(argv[i]);
                break;
            case 'g':
                param.gamma = atof(argv[i]);
                break;
            case 'r':
                param.coef0 = atof(argv[i]);
                break;
            case 'n':
                param.nu = atof(argv[i]);
                break;
            case 'm':
                param.cache_size = atof(argv[i]);
                break;
            case 'c':
                param.C = atof(argv[i]);
                break;
            case 'e':
                param.eps = atof(argv[i]);
                break;
            case 'p':
                param.p = atof(argv[i]);
                break;
            case 'h':
                param.shrinking = atoi(argv[i]);
                break;
            case 'b':
                param.probability = atoi(argv[i]);
                break;
            case 'q':
                print_func = svm_print_null;
                i--;
                break;
            case 'v':
                cross_validation = 1;
                nr_fold = atoi(argv[i]);
                if (nr_fold < 2) {
                    System.err.print("n-fold cross validation: n must >= 2\n");
                    exit_with_help();
                }
                break;
            case 'w':
                ++param.nr_weight;
                {
                    int[] old = param.weight_label;
                    param.weight_label = new int[param.nr_weight];
                    System.arraycopy(old, 0, param.weight_label, 0,
                            param.nr_weight - 1);
                }

                {
                    double[] old = param.weight;
                    param.weight = new double[param.nr_weight];
                    System.arraycopy(old, 0, param.weight, 0,
                            param.nr_weight - 1);
                }

                param.weight_label[param.nr_weight - 1] = atoi(argv[i - 1]
                        .substring(2));
                param.weight[param.nr_weight - 1] = atof(argv[i]);
                break;
            default:
                System.err.print("Unknown option: " + argv[i - 1] + "\n");
                exit_with_help();
            }
        }

        svm.svm_set_print_string_function(print_func);

        // determine filenames

        if (i >= argv.length)
            exit_with_help();

        input_file_name = argv[i];

        if (i < argv.length - 1)
            model_file_name = argv[i + 1];
        else {
            int p = argv[i].lastIndexOf('/');
            ++p; // whew...
            model_file_name = argv[i].substring(p) + ".model";
        }
    }

    // read in a problem (in svmlight format)

    private void read_problem() throws IOException {
        BufferedReader fp = new BufferedReader(new FileReader(input_file_name));
        Vector<Double> vy = new Vector<Double>();
        Vector<svm_node[]> vx = new Vector<svm_node[]>();
        int max_index = 0;

        while (true) {
            String line = fp.readLine();
            if (line == null)
                break;

            StringTokenizer st = new StringTokenizer(line, " \t\n\r\f:");

            vy.addElement(atof(st.nextToken()));
            int m = st.countTokens() / 2;
            svm_node[] x = new svm_node[m];
            for (int j = 0; j < m; j++) {
                x[j] = new svm_node();
                x[j].index = atoi(st.nextToken());
                x[j].value = atof(st.nextToken());
            }
            if (m > 0)
                max_index = Math.max(max_index, x[m - 1].index);
            vx.addElement(x);
        }

        prob = new svm_problem();
        prob.l = vy.size();
        prob.x = new svm_node[prob.l][];
        for (int i = 0; i < prob.l; i++)
            prob.x[i] = vx.elementAt(i);
        prob.y = new double[prob.l];
        for (int i = 0; i < prob.l; i++)
            prob.y[i] = vy.elementAt(i);

        if (param.gamma == 0 && max_index > 0)
            param.gamma = 1.0 / max_index;

        if (param.kernel_type == svm_parameter.PRECOMPUTED)
            for (int i = 0; i < prob.l; i++) {
                if (prob.x[i][0].index != 0) {
                    System.err
                            .print("Wrong kernel matrix: first column must be 0:sample_serial_number\n");
                    System.exit(1);
                }
                if ((int) prob.x[i][0].value <= 0
                        || (int) prob.x[i][0].value > max_index) {
                    System.err
                            .print("Wrong input format: sample_serial_number out of range\n");
                    System.exit(1);
                }
            }

        fp.close();
    }
}