pysvmlight / svmlight / svmlight.py

from ctypes import *

VERSION = "V6.02"
VERSION_DATE = "14.08.08"

CFLOAT = c_float
FNUM   = c_long
FVAL   = c_float

MAXFEATNUM = 99999999

LINEAR  = 0
POLY    = 1
RBF     = 2
SIGMOID = 3

CLASSIFICATION = 1
REGRESSION     = 2
RANKING        = 3
OPTIMIZATION   = 4

MAXSHRINK = 50000
svm = CDLL("./svmlight.so")


class WORD(Structure):
	_fields_ = [("wnum",   FNUM),
                ("weight", FVAL)]


class SVECTOR(Structure):
	_fields_ = [("words",       POINTER(WORD)),
                ("twonorm_sq",  c_double),
                ("userdefined", POINTER(c_char)),
                ("kernel_id",   c_long),
                ("next",        POINTER(SVECTOR),
                ("factor",      c_double)]


class DOC(Structure):
    _fields_ = [("docnum",     c_long),
                ("queryid",    c_long),
                ("costfactor", c_double),
                ("slackid",    c_long),
                ("fvec",       POINTER(SVECTOR))]

class LEARN_PARM(Structure):
    _fields_ = [("type",                  c_long),
                ("svm_c",                 c_double),
                ("eps",                   c_double),
                ("svm_costratio",         c_double),
                ("transduction_posratio", c_double),
                ("biased_hyperplane",     c_long),
                ("sharedslack",           c_long),
                ("svm_maxqpsize",         c_long),
                ("svm_newvarsinqp",       c_long),
                ("kernel_cache_size",     c_long),
                ("epsilon_crit",          c_double),
                ("epsilon_shrink",        c_double),
                ("svm_iter_to_shrink",    c_long),
                ("maxiter",               c_long),
                ("remove_inconsistent",   c_long),
                ("skip_final_opt_check",  c_long),
                ("compute_loo",           c_long),
                ("rho",                   c_double),
                ("xa_depth",              c_long),
                ("predfile",              (c_char * 200)()),
                ("alphafile",             (c_char * 200)()),
                ("epsilon_const",         c_double),
                ("epsilon_a",             c_double),
                ("opt_precision",         c_double),
                ("svm_c_steps",           c_long),
                ("svm_c_factor",          c_double),
                ("svm_costratio_unlab",   c_double),
                ("svm_unlabbound",        c_double),
                ("svm_cost",              POINTER(c_double)),
                ("totwords",              c_long)]

class KERNEL_PARM(Structure):
    _fields_ = [("kernel_type",     c_long),
                ("poly_degree",     c_long),
                ("rbf_gamma",       c_double),
                ("coef_lin",        c_double),
                ("coef_const",      c_double),
                ("custom",          (c_char * 50)())]

class MODEL(Structure):
    _fields_ = [("sv_num",          c_long),
                ("at_upper_bound",  c_long),
                ("b",               c_double),
                ("supvec",          POINTER(POINTER(DOC))),
                ("alpha",           POINTER(c_double)),
                ("index",           POINTER(c_long)),
                ("totwords",        c_long),
                ("totdoc",          c_long),
                ("kernel_parm",     KERNEL_PARM),
                ("loo_error",       c_double),
                ("loo_recall",      c_double),
                ("loo_precision",   c_double),
                ("xa_error",        c_double),
                ("xa_recall",       c_double),
                ("xa_precision",    c_double),
                ("lin_weights",     POINTER(c_double)),
                ("maxdiff",         c_double)]

class QP(Structure):
	_fields_ = [("opt_n",     c_long),
                ("opt_m",     c_long),
                ("opt_ce",    POINTER(c_double)),
                ("opt_ce0",   POINTER(c_double)),
                ("opt_g",     POINTER(c_double)),
                ("opt_g0",    POINTER(c_double)),
                ("opt_xinit", POINTER(c_double)),
                ("opt_low",   POINTER(c_double)),
                ("opt_up",    POINTER(c_double))]

class KERNEL_CACHE(Structure):
  _fields_ = [("index",         POINTER(c_long)),
              ("buffer",        POINTER(CFLOAT)),
              ("invindex",      POINTER(c_long)),
              ("active2totdoc", POINTER(c_long)),
              ("totdoc2active", POINTER(c_long)),
              ("lru",           POINTER(c_long)),
              ("occu",          POINTER(c_long)),
              ("elems",         c_long),
              ("max_elems",     c_long),
              ("time",          c_long),
              ("activenum",     c_long),
              ("buffsize",      c_long)]

class TIMING(Structure):
    _fields_ = [("time_kernel",     c_long),
                ("time_opti",       c_long),
                ("time_shrink",     c_long),
                ("time_update",     c_long),
                ("time_model",      c_long),
                ("time_check",      c_long),
                ("time_select",     c_long)]

class SHRINK_STATE(Structure):
    _fields_ = [("active",          POINTER(c_long)),
                ("inactive_since",  POINTER(c_long)),
                ("deactnum",        c_long),
                ("a_history",       POINTER(POINTER(c_double))),
                ("maxhistory",      c_long),
                ("last_a",          POINTER(c_double)),
                ("last_lin",        POINTER(c_double))]


if __name__ == "__main__":
	svec = SVECTOR()
	for i, word in enumerate(svec.words):
		word.wnum = i

	print svec.words

	resize(svec.words, 64)

	for word in svec.words:
		print word.wnum

def svm_learn2(*args, **kwds):
    docs = POINTER(POINTER(DOC()))
    target = POINTER(c_double)
    totwords = c_int
	totdoc = c_int
    kernel_cache = POINTER(KERNEL_CACHE)
    learn_parm = LEARN_PARM
    kernel_parm = KERNEL_PARM
    verbosity = c_long
    #doclist = POINTER(PyObject) #FIXME
    model = POINTER(MODEL)
    result = POINTER(MODEL_AND_DOCS)
	# DO THIS ONE!

	# NULL: alpha in
    if learn_parm.type == CLASSIFICATION {
        svm.svm_learn_classification(docs, target, totdoc, totwords,
			addressof(learn_parm), addressof(kernel_parm), kernel_cache,
			model, None)
    }


'''

static PyObject *svm_learn(PyObject *self, PyObject *args, PyObject *kwds)
{
    #DOC **docs;
    double* target;
    int totwords, totdoc;
    KERNEL_CACHE *kernel_cache;
    LEARN_PARM learn_parm;
    KERNEL_PARM kernel_parm;
    long verbosity;
    PyObject *doclist;
    MODEL *model;
    MODEL_AND_DOCS *result;

    if(!PyArg_ParseTuple(args, "O", &doclist))
        return NULL;
    read_learning_parameters(kwds, &verbosity, &learn_parm, &kernel_parm);
    if(!unpack_doclist(doclist, &docs, &target, &totwords, &totdoc))
        return NULL;

    model = malloc(sizeof(MODEL));
    if(kernel_parm.kernel_type == LINEAR)
        kernel_cache = NULL;
    else
        kernel_cache = kernel_cache_init(totdoc, learn_parm.kernel_cache_size);

	# DO THIS ONE!
    if(learn_parm.type == CLASSIFICATION) {
        svm_learn_classification(docs, target, totdoc, totwords, &learn_parm,
                                 &kernel_parm, kernel_cache, model, NULL /* alpha_in */);
    }
    else if(learn_parm.type == REGRESSION) {
        svm_learn_regression(docs, target, totdoc, totwords, &learn_parm,
                             &kernel_parm, &kernel_cache, model);
    }
    else if(learn_parm.type == RANKING) {
        svm_learn_ranking(docs, target, totdoc, totwords, &learn_parm,
                          &kernel_parm, &kernel_cache, model);
    }
    else if(learn_parm.type == OPTIMIZATION) {
        svm_learn_optimization(docs, target, totdoc, totwords, &learn_parm,
                               &kernel_parm, kernel_cache, model, NULL /* alpha_in */);
    }
'''
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.