libbmrm.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 3 of the License, or
 * (at your option) any later version.
 *
 * libbmrm.h: Implementation of the BMRM solver for SO training
 *
 * Copyright (C) 2012 Michal Uricar, uricamic@cmp.felk.cvut.cz
 *
 * Implementation of the BMRM solver
 *--------------------------------------------------------------------- */

#include <shogun/lib/common.h>
#include <shogun/structure/StructuredModel.h>

#ifndef libbmrm_h
#define libbmrm_h

#define LIBBMRM_PLUS_INF (-log(0.0))
#define LIBBMRM_CALLOC(x, y) calloc(x, y)
#define LIBBMRM_REALLOC(x, y) realloc(x, y)
#define LIBBMRM_FREE(x) SG_FREE(x)
#define LIBBMRM_MEMCPY(x, y, z) memcpy(x, y, z)
#define LIBBMRM_MEMMOVE(x, y, z) memmove(x, y, z)
#define LIBBMRM_INDEX(ROW, COL, NUM_ROWS) ((COL)*(NUM_ROWS)+(ROW))
#define LIBBMRM_ABS(A) ((A) < 0 ? -(A) : (A))

namespace shogun
{
struct bmrm_return_value_T
{
    bmrm_return_value_T()
    {
        nIter = 0;
        nCP = 0;
        nzA = 0;
        Fp = 0;
        Fd = 0;
        qp_exitflag = 0;
        exitflag = 0;
    };

    ~bmrm_return_value_T() { };

    bool load_serializable(CSerializableFile* file, const char* prefix="") { return false; }
    
    bool save_serializable(CSerializableFile* file, const char* prefix="") { return false; }

    uint32_t nIter;

    uint32_t nCP;

    uint32_t nzA;

    float64_t Fp;

    float64_t Fd;

    int8_t qp_exitflag;

    int8_t exitflag;

    SGVector< float64_t > hist_Fp;

    SGVector< float64_t > hist_Fd;

    SGVector< float64_t > hist_wdist;
};

IGNORE_IN_CLASSLIST struct bmrm_ll {
    bmrm_ll   *prev;
    bmrm_ll   *next;
    float64_t   *address;
    uint32_t    idx;
};

void add_cutting_plane(
        bmrm_ll**   tail,
        bool*       map,
        float64_t*  A,
        uint32_t    free_idx,
        float64_t*  cp_data,
        uint32_t    dim);

void remove_cutting_plane(
        bmrm_ll**   head,
        bmrm_ll**   tail,
        bool*       map,
        float64_t*  icp);

inline float64_t * get_cutting_plane(bmrm_ll *ptr) { return ptr->address; }

inline uint32_t find_free_idx(bool *map, uint32_t size)
{ for(uint32_t i=0; i<size; ++i) if (map[i]) return i; return size+1; }

bmrm_return_value_T svm_bmrm_solver(
        CStructuredModel *model,
        float64_t        *W,
        float64_t        TolRel,
        float64_t        TolAbs,
        float64_t        _lambda,
        uint32_t         _BufSize,
        bool             cleanICP,
        uint32_t         cleanAfter,
        float64_t        K,
        uint32_t         Tmax,
        bool             verbose
        );

}

#endif /* libbmrm_h */