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
 *--------------------------------------------------------------------- */

#ifndef libbmrm_h
#define libbmrm_h

#include <shogun/lib/config.h>

#include <shogun/lib/common.h>
#include <shogun/structure/BmrmStatistics.h>
#include <shogun/structure/DualLibQPBMSOSVM.h>

#define LIBBMRM_PLUS_INF (-log(0.0))
#define LIBBMRM_CALLOC(x, y) SG_CALLOC(y, x)
#define LIBBMRM_REALLOC(x, y) SG_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
{
extern uint32_t BufSize;

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

IGNORE_IN_CLASSLIST struct ICP_stats
{
    uint32_t maxCPs;

    uint32_t* ICPcounter;

    float64_t** ICPs;

    uint32_t* ACPs;

    float64_t* H_buff;
};

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);

void clean_icp(ICP_stats* icp_stats,
        BmrmStatistics& bmrm,
        bmrm_ll** head,
        bmrm_ll** tail,
        float64_t*& H,
        float64_t*& diag_H,
        float64_t*& beta,
        bool*& map,
        uint32_t cleanAfter,
        float64_t*& b,
        uint32_t*& I,
        uint32_t cp_models = 0
        );

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;
    SG_SERROR("No free index available in CP buffer of size %d.\n", size);
    return size-1;
}

BmrmStatistics svm_bmrm_solver(
        CDualLibQPBMSOSVM  *machine,
        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               store_train_info
        );

}

#endif /* libbmrm_h */