GenSVMgrid.c

Go to the documentation of this file.

#include "gensvm_checks.h"
#include "gensvm_cmdarg.h"
#include "gensvm_io.h"
#include "gensvm_gridsearch.h"
#include "gensvm_consistency.h"

#define MINARGS 2

extern FILE *GENSVM_OUTPUT_FILE;
extern FILE *GENSVM_ERROR_FILE;

// function declarations
void exit_with_help(char **argv);
void parse_command_line(int argc, char **argv, char *input_filename);
void read_grid_from_file(char *input_filename, struct GenGrid *grid);

void exit_with_help(char **argv)
{
    printf("This is GenSVM, version %s.\n", VERSION_STRING);
    printf("Copyright (C) 2016, G.J.J. van den Burg.\n");
    printf("This program is free software, see the LICENSE file "
            "for details.\n\n");
    printf("Usage: %s [options] grid_file\n", argv[0]);
    printf("Options:\n");
    printf("-h | -help : print this help.\n");
    printf("-q         : quiet mode (no output, not even errors!)\n");
    printf("-x         : data files are in LibSVM/SVMlight format\n");

    exit(EXIT_FAILURE);
}

int main(int argc, char **argv)
{
    bool libsvm_format = false;
    char input_filename[GENSVM_MAX_LINE_LENGTH];

    struct GenGrid *grid = gensvm_init_grid();
    struct GenData *train_data = gensvm_init_data();
    struct GenData *test_data = gensvm_init_data();
    struct GenQueue *q = gensvm_init_queue();

    if (argc < MINARGS || gensvm_check_argv(argc, argv, "-help")
            || gensvm_check_argv_eq(argc, argv, "-h") )
        exit_with_help(argv);
    parse_command_line(argc, argv, input_filename);
    libsvm_format = gensvm_check_argv(argc, argv, "-x");

    note("Reading grid file\n");
    read_grid_from_file(input_filename, grid);

    note("Reading data from %s\n", grid->train_data_file);
    if (libsvm_format)
        gensvm_read_data_libsvm(train_data, grid->train_data_file);
    else
        gensvm_read_data(train_data, grid->train_data_file);

    // check labels of training data
    gensvm_check_outcome_contiguous(train_data);
    if (!gensvm_check_outcome_contiguous(train_data)) {
        err("[GenSVM Error]: Class labels should start from 1 and "
                "have no gaps. Please reformat your data.\n");
        exit(EXIT_FAILURE);
    }

    // check if we are sparse and want nonlinearity
    if (train_data->Z == NULL && grid->kerneltype != K_LINEAR) {
        err("[GenSVM Warning]: Sparse matrices with nonlinear kernels "
                "are not yet supported. Dense matrices will "
                "be used.\n");
        train_data->RAW = gensvm_sparse_to_dense(train_data->spZ);
        train_data->Z = train_data->RAW;
        gensvm_free_sparse(train_data->spZ);
    }

    if (grid->traintype == TT) {
        err("[GenSVM Warning]: Using test datasets in a grid search "
                "is not yet supported in GenSVM.\n"
                "                  The test dataset will be "
                "ignored during training.\n");
        //note("Reading data from %s\n", grid->test_data_file);
        //gensvm_read_data(test_data, grid->test_data_file);
    }

    note("Creating queue\n");
    gensvm_fill_queue(grid, q, train_data, test_data);

    srand(time(NULL));

    note("Starting training\n");
    gensvm_train_queue(q);
    note("Training finished\n");

    if (grid->repeats > 0) {
        gensvm_consistency_repeats(q, grid->repeats, grid->percentile);
    }

    gensvm_free_queue(q);
    gensvm_free_grid(grid);
    gensvm_free_data(train_data);
    gensvm_free_data(test_data);

    note("Done.\n");
    return 0;
}

void parse_command_line(int argc, char **argv, char *input_filename)
{
    int i;

    GENSVM_OUTPUT_FILE = stdout;
    GENSVM_ERROR_FILE = stderr;

    for (i=1; i<argc; i++) {
        if (argv[i][0] != '-') break;
        if (++i>=argc)
            exit_with_help(argv);
        switch (argv[i-1][1]) {
            case 'q':
                GENSVM_OUTPUT_FILE = NULL;
                GENSVM_ERROR_FILE = NULL;
                i--;
                break;
            case 'x':
                i--;
                break;
            default:
                fprintf(stderr, "Unknown option: -%c\n",
                        argv[i-1][1]);
                exit_with_help(argv);
        }
    }

    if (i >= argc)
        exit_with_help(argv);

    strcpy(input_filename, argv[i]);
}

KernelType parse_kernel_str(char *kernel_line)
{
    if (str_endswith(kernel_line, "LINEAR\n")) {
        return K_LINEAR;
    } else if (str_endswith(kernel_line, "POLY\n")) {
        return K_POLY;
    } else if (str_endswith(kernel_line, "RBF\n")) {
        return K_RBF;
    } else if (str_endswith(kernel_line, "SIGMOID\n")) {
        return K_SIGMOID;
    } else {
        fprintf(stderr, "Unknown kernel specified on line: %s\n",
                kernel_line);
        exit(EXIT_FAILURE);
    }
}

void read_grid_from_file(char *input_filename, struct GenGrid *grid)
{
    long i, nr = 0;
    FILE *fid;
    char buffer[GENSVM_MAX_LINE_LENGTH];
    char train_filename[GENSVM_MAX_LINE_LENGTH];
    char test_filename[GENSVM_MAX_LINE_LENGTH];
    double *params = Calloc(double, GENSVM_MAX_LINE_LENGTH);
    long *lparams = Calloc(long, GENSVM_MAX_LINE_LENGTH);

    fid = fopen(input_filename, "r");
    if (fid == NULL) {
        fprintf(stderr, "Error opening grid file %s\n",
                input_filename);
        exit(EXIT_FAILURE);
    }
    grid->traintype = CV;
    while ( fgets(buffer, GENSVM_MAX_LINE_LENGTH, fid) != NULL ) {
        Memset(params, double,  GENSVM_MAX_LINE_LENGTH);
        Memset(lparams, long, GENSVM_MAX_LINE_LENGTH);
        if (str_startswith(buffer, "train:")) {
            sscanf(buffer, "train: %s\n", train_filename);
            grid->train_data_file = Calloc(char,
                    GENSVM_MAX_LINE_LENGTH);
            strcpy(grid->train_data_file, train_filename);
        } else if (str_startswith(buffer, "test:")) {
            sscanf(buffer, "test: %s\n", test_filename);
            grid->test_data_file = Calloc(char,
                    GENSVM_MAX_LINE_LENGTH);
            strcpy(grid->test_data_file, test_filename);
            grid->traintype = TT;
        } else if (str_startswith(buffer, "p:")) {
            nr = all_doubles_str(buffer, 2, params);
            grid->ps = Calloc(double, nr);
            for (i=0; i<nr; i++)
                grid->ps[i] = params[i];
            grid->Np = nr;
        } else if (str_startswith(buffer, "lambda:")) {
            nr = all_doubles_str(buffer, 7, params);
            grid->lambdas = Calloc(double, nr);
            for (i=0; i<nr; i++)
                grid->lambdas[i] = params[i];
            grid->Nl = nr;
        } else if (str_startswith(buffer, "kappa:")) {
            nr = all_doubles_str(buffer, 6, params);
            grid->kappas = Calloc(double, nr);
            for (i=0; i<nr; i++)
                grid->kappas[i] = params[i];
            grid->Nk = nr;
        } else if (str_startswith(buffer, "epsilon:")) {
            nr = all_doubles_str(buffer, 8, params);
            grid->epsilons = Calloc(double, nr);
            for (i=0; i<nr; i++)
                grid->epsilons[i] = params[i];
            grid->Ne = nr;
        } else if (str_startswith(buffer, "weight:")) {
            nr = all_longs_str(buffer, 7, lparams);
            grid->weight_idxs = Calloc(int, nr);
            for (i=0; i<nr; i++)
                grid->weight_idxs[i] = lparams[i];
            grid->Nw = nr;
        } else if (str_startswith(buffer, "folds:")) {
            nr = all_longs_str(buffer, 6, lparams);
            grid->folds = lparams[0];
            if (nr > 1)
                fprintf(stderr, "Field \"folds\" only takes "
                        "one value. Additional "
                        "fields are ignored.\n");
        } else if (str_startswith(buffer, "repeats:")) {
            nr = all_longs_str(buffer, 8, lparams);
            grid->repeats = lparams[0];
            if (nr > 1)
                fprintf(stderr, "Field \"repeats\" only "
                        "takes one value. Additional "
                        "fields are ignored.\n");
        } else if (str_startswith(buffer, "percentile:")) {
            nr = all_doubles_str(buffer, 11, params);
            grid->percentile = params[0];
            if (nr > 1)
                fprintf(stderr, "Field \"percentile\" only "
                        "takes one value. Additional "
                        "fields are ignored.\n");
        } else if (str_startswith(buffer, "kernel:")) {
            grid->kerneltype = parse_kernel_str(buffer);
        } else if (str_startswith(buffer, "gamma:")) {
            nr = all_doubles_str(buffer, 6, params);
            if (grid->kerneltype == K_LINEAR) {
                fprintf(stderr, "Field \"gamma\" ignored, "
                        "linear kernel is used.\n");
                grid->Ng = 0;
                break;
            }
            grid->gammas = Calloc(double, nr);
            for (i=0; i<nr; i++)
                grid->gammas[i] = params[i];
            grid->Ng = nr;
        } else if (str_startswith(buffer, "coef:")) {
            nr = all_doubles_str(buffer, 5, params);
            if (grid->kerneltype == K_LINEAR ||
                grid->kerneltype == K_RBF) {
                fprintf(stderr, "Field \"coef\" ignored with "
                        "specified kernel.\n");
                grid->Nc = 0;
                break;
            }
            grid->coefs = Calloc(double, nr);
            for (i=0; i<nr; i++)
                grid->coefs[i] = params[i];
            grid->Nc = nr;
        } else if (str_startswith(buffer, "degree:")) {
            nr = all_doubles_str(buffer, 7, params);
            if (grid->kerneltype != K_POLY) {
                fprintf(stderr, "Field \"degree\" ignored "
                        "with specified kernel.\n");
                grid->Nd = 0;
                break;
            }
            grid->degrees = Calloc(double, nr);
            for (i=0; i<nr; i++)
                grid->degrees[i] = params[i];
            grid->Nd = nr;
        } else {
            fprintf(stderr, "Cannot find any parameters on line: "
                    "%s\n", buffer);
        }
    }

    free(params);
    free(lparams);
    fclose(fid);
}