lib_learner.cpp

orange源码 数据挖掘技术

    if (p2nn->bases) {
      buf.writeChar(1);
      buf.writeBuf(p2nn->bases, 2 * nAttrs * sizeof(double));
    }
    else
      buf.writeChar(0);

    if (p2nn->radii) {
      buf.writeChar(1);
      buf.writeBuf(p2nn->radii, 2 * nAttrs * sizeof(double));
    }
    else
      buf.writeChar(0);

    if (p2nn->projections) {
      buf.writeChar(1);
      buf.writeBuf(p2nn->projections, 3 * nExamples * sizeof(double));
    }
    else
      buf.writeChar(0);

    buf.writeDouble(p2nn->minClass);
    buf.writeDouble(p2nn->maxClass);
   
    return Py_BuildValue("O(Os#)N", getExportedFunction("__pickleLoaderP2NN"),
                                    self->ob_type,
                                    buf.buf, buf.length(),
                                    packOrangeDictionary(self));
  PyCATCH
}


PyObject *__pickleLoaderP2NN(PyObject *, PyObject *args) PYARGS(METH_VARARGS, "(type, packed_data)")
{
  PyTRY
    PyTypeObject *type;
    char *pbuf;
    int bufSize;
    if (!PyArg_ParseTuple(args, "Os#:__pickleLoaderP2NN", &type, &pbuf, &bufSize))    
      return NULL;

    TCharBuffer buf(pbuf);

    const int nAttrs = buf.readInt();
    const int nExamples = buf.readInt();

    TP2NN *p2nn = new TP2NN(nAttrs, nExamples);
    if (buf.readChar()) {
      buf.readBuf(p2nn->bases, 2 * nAttrs * sizeof(double));
    }
    else {
      delete p2nn->bases;
      p2nn->bases = NULL;
    }

    if (buf.readChar()) {
      buf.readBuf(p2nn->radii, 2 * nAttrs * sizeof(double));
    }
    else {
      delete p2nn->radii;
      p2nn->radii = NULL;
    }

    if (buf.readChar()) {
      buf.readBuf(p2nn->projections, 3 * nExamples * sizeof(double));
    }
    else {
      delete p2nn->projections;
      p2nn->projections = NULL;
    }

    p2nn->minClass = buf.readDouble();
    p2nn->maxClass = buf.readDouble();

    return WrapNewOrange(p2nn, type);
  PyCATCH
}


C_CALL(kNNLearner, Learner, "([examples] [, weight=, k=] -/-> Classifier")
C_NAMED(kNNClassifier, ClassifierFD, "([k=, weightID=, findNearest=])")


/************* Logistic Regression ************/

#include "logistic.hpp"
C_CALL(LogRegLearner, Learner, "([examples[, weight=]]) -/-> Classifier")
C_NAMED(LogRegClassifier, ClassifierFD, "([probabilities=])")


PyObject *LogRegFitter_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange, "<abstract>")
{ if (type == (PyTypeObject *)&PyOrLogRegFitter_Type)
    return setCallbackFunction(WrapNewOrange(mlnew TLogRegFitter_Python(), type), args);
  else
    return WrapNewOrange(mlnew TLogRegFitter_Python(), type);
}

PyObject *LogRegFitter__reduce__(PyObject *self)
{
  return callbackReduce(self, PyOrLogRegFitter_Type);
}


C_CALL(LogRegFitter_Cholesky, LogRegFitter, "([example[, weightID]]) -/-> (status, beta, beta_se, likelihood) | (status, attribute)")

PYCLASSCONSTANT_INT(LogRegFitter, OK, TLogRegFitter::OK)
PYCLASSCONSTANT_INT(LogRegFitter, Infinity, TLogRegFitter::Infinity)
PYCLASSCONSTANT_INT(LogRegFitter, Divergence, TLogRegFitter::Divergence)
PYCLASSCONSTANT_INT(LogRegFitter, Constant, TLogRegFitter::Constant)
PYCLASSCONSTANT_INT(LogRegFitter, Singularity, TLogRegFitter::Singularity)

PyObject *LogRegLearner_fitModel(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(examples[, weight])")
{
  PyTRY
      PExampleGenerator egen;
      int weight = 0;
      if (!PyArg_ParseTuple(args, "O&|O&:LogRegLearner", pt_ExampleGenerator, &egen, pt_weightByGen(egen), &weight))
  	    return PYNULL;

	  CAST_TO(TLogRegLearner, loglearn)

	  int error;
	  PVariable variable;
	  PClassifier classifier;

	  classifier = loglearn->fitModel(egen, weight, error, variable);
	  if (error <= TLogRegFitter::Divergence)
		  return Py_BuildValue("N", WrapOrange(classifier));
	  else 
		  return Py_BuildValue("N", WrapOrange(variable));
  PyCATCH
}


PyObject *LogRegFitter_call(PyObject *self, PyObject *args, PyObject *keywords) PYDOC("(examples[, weightID]) -/-> (status, beta, beta_se, likelihood) | (status, attribute)")
{
  PyTRY
    NO_KEYWORDS

    int weight;
    PExampleGenerator egen = exampleGenFromArgs(args, weight);
    if (!egen)
      return PYNULL;

    CAST_TO(TLogRegFitter, fitter)

    PAttributedFloatList beta, beta_se;
    float likelihood;
    int error;
    PVariable attribute;
    
    beta = (*fitter)(egen, weight, beta_se, likelihood, error, attribute);

    if (error <= TLogRegFitter::Divergence)
      return Py_BuildValue("iNNf", error, WrapOrange(beta), WrapOrange(beta_se), likelihood);
    else
      return Py_BuildValue("iN", error, WrapOrange(attribute));

  PyCATCH
}

/************* SVM ************/

#include "svm.hpp"
C_CALL(SVMLearner, Learner, "([examples] -/-> Classifier)")
BASED_ON(SVMClassifier, Classifier)
NO_PICKLE(SVMClassifier)

PYCLASSCONSTANT_INT(SVMLearner, C_SVC, 0)
PYCLASSCONSTANT_INT(SVMLearner, NU_SVC, 1)
PYCLASSCONSTANT_INT(SVMLearner, ONE_CLASS, 2)
PYCLASSCONSTANT_INT(SVMLearner, EPSILON_SVR, 3)
PYCLASSCONSTANT_INT(SVMLearner, NU_SVR, 4)

PYCLASSCONSTANT_INT(SVMLearner, LINEAR, 0)
PYCLASSCONSTANT_INT(SVMLearner, POLY, 1)
PYCLASSCONSTANT_INT(SVMLearner, RBF, 2)
PYCLASSCONSTANT_INT(SVMLearner, SIGMOID, 3)
PYCLASSCONSTANT_INT(SVMLearner, CUSTOM, 4)


PyObject *KernelFunc_new(PyTypeObject *type, PyObject *args, PyObject *keywords)  BASED_ON(Orange, "<abstract>")
{ if (type == (PyTypeObject *)&PyOrKernelFunc_Type)
    return setCallbackFunction(WrapNewOrange(mlnew TKernelFunc_Python(), type), args);
  else
    return WrapNewOrange(mlnew TKernelFunc_Python(), type);
}


PyObject *KernelFunc__reduce__(PyObject *self)
{
  return callbackReduce(self, PyOrKernelFunc_Type);
}


PyObject *KernelFunc_call(PyObject *self, PyObject *args, PyObject *keywords) PYDOC("(Example, Example) -> float")
{
  PyTRY
    NO_KEYWORDS

    if (PyOrange_OrangeBaseClass(self->ob_type) == &PyOrKernelFunc_Type) {
      PyErr_Format(PyExc_SystemError, "KernelFunc.call called for '%s': this may lead to stack overflow", self->ob_type->tp_name);
      return PYNULL;
    }

    float f;
    PExample e1,e2;
	if (!PyArg_ParseTuple(args, "O&O&", cc_Example, &e1, cc_Example, &e2))
		return NULL;
	f=SELF_AS(TKernelFunc)(e1.getReference(),e2.getReference());
	return Py_BuildValue("f", f);
  PyCATCH
}


/************* BAYES ************/

#include "bayes.hpp"
C_CALL(BayesLearner, Learner, "([examples], [weight=, estimate=] -/-> Classifier")
C_NAMED(BayesClassifier, ClassifierFD, "([probabilities=])")

PyObject *BayesClassifier_p(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(class, example) -> float")
{ PyTRY
    CAST_TO(TBayesClassifier, me);

    PyObject *pyvalue;
    TValue value;
    TExample *ex;
    if (   !PyArg_ParseTuple(args, "OO&:BayesClassifier.p", &pyvalue, ptr_Example, &ex)
        || !convertFromPython(pyvalue, value, me->domain->classVar))
      return PYNULL;
      
    return PyFloat_FromDouble((double)SELF_AS(TBayesClassifier).p(value, *ex));

  PyCATCH
}


/************* LINEAR REGRESSION ************/

#include "linreg.hpp"
C_CALL(LinRegLearner, Learner, "([examples] -/-> Classifier)")
C_NAMED(LinRegClassifier, ClassifierFD, "([coefficients=, coefficients_se=, SSres=, SStot=])")


/************* LWR ************/

#include "lwr.hpp"
C_CALL(LWRLearner, Learner, "([examples] -/-> Classifier)")
C_NAMED(LWRClassifier, ClassifierFD, "([findNearestConstructor=, linRegLearner=, k=, rankWeight=])")


/************* RULES ************/

#include "rulelearner.hpp"

C_NAMED(Rule, Orange, "()")

C_NAMED(RuleValidator_LRS, RuleValidator, "([alpha=0.05,min_coverage=0,max_rule_complexity=0,min_quality=numeric_limits<float>::min()])")

C_NAMED(RuleEvaluator_Entropy, RuleEvaluator, "()")
C_NAMED(RuleEvaluator_Laplace, RuleEvaluator, "()")

C_NAMED(RuleBeamFinder, RuleFinder, "([validator=, evaluator=, initializer=, refiner=, candidateSelector=, ruleFilter=])")

C_NAMED(RuleBeamInitializer_Default, RuleBeamInitializer, "()")

C_NAMED(RuleBeamRefiner_Selector, RuleBeamRefiner, "([discretization=])")

C_NAMED(RuleBeamCandidateSelector_TakeAll, RuleBeamCandidateSelector, "()")

C_NAMED(RuleBeamFilter_Width, RuleBeamFilter, "([width=5])")

C_NAMED(RuleDataStoppingCriteria_NoPositives, RuleDataStoppingCriteria, "()")

C_NAMED(RuleCovererAndRemover_Default, RuleCovererAndRemover, "()")

C_NAMED(RuleStoppingCriteria_NegativeDistribution, RuleStoppingCriteria, "()")
C_CALL(RuleLearner, Learner, "([examples[, weightID]]) -/-> Classifier")

ABSTRACT(RuleClassifier, Classifier)
C_NAMED(RuleClassifier_firstRule, RuleClassifier, "([rules,examples[,weightID]])")

PyObject *Rule_call(PyObject *self, PyObject *args, PyObject *keywords)
{
  PyTRY
    NO_KEYWORDS

    if (PyTuple_Size(args)==1) {
      PyObject *pyex = PyTuple_GET_ITEM(args, 0);
      if (PyOrExample_Check(pyex))
        return PyInt_FromLong(PyOrange_AsRule(self)->call(PyExample_AS_ExampleReference(pyex)) ? 1 : 0);
    }