lib_preprocess.cpp

orange源码 数据挖掘技术

      delete gen;
      return NULL;
    }

    return WrapNewOrange(gen, type);
  PyCATCH
}


PyObject *SubsetsGenerator_minMaxSize_iterator__reduce__(PyObject *self)
{
  PyTRY
    CAST_TO(TSubsetsGenerator_minMaxSize_iterator, gen);

    TCharBuffer buf((gen->counter.size() + 5) * sizeof(int));
    buf.writeInt(gen->B);
    buf.writeInt(gen->max);
    packCounter(gen->counter, buf);
    buf.writeChar(gen->moreToCome ? 1 : 0);

    return Py_BuildValue("O(OOs#)N", getExportedFunction("__pickleLoaderSubsetsGeneratorMinMaxSizeIterator"),
                                    self->ob_type,
                                    WrapOrange(gen->varList),
                                    buf.buf, buf.length(),
                                    packOrangeDictionary(self));
 PyCATCH
}


PyObject *__pickleLoaderSubsetsGeneratorMinMaxSizeIterator(PyObject *, PyObject *args) PYARGS(METH_VARARGS, "(type, varList, packed_counter)")
{
  PyTRY
    PyTypeObject *type;
    PVarList varList;
    char *pbuf;
    int bufSize;
    if (!PyArg_ParseTuple(args, "OO&s#:__pickleLoaderSubsetsGenerator_minMaxSizeIterator", &type, ccn_VarList, &varList, &pbuf, &bufSize))
      return NULL;

    TCharBuffer buf(pbuf);

    const int B = buf.readInt();
    const int max = buf.readInt();
    TSubsetsGenerator_minMaxSize_iterator *gen = new TSubsetsGenerator_minMaxSize_iterator(varList, B, max);
    unpackCounter(buf, gen->counter);
    gen->moreToCome = buf.readChar() != 0;

    return WrapNewOrange(gen, type);
  PyCATCH
}




PyObject *SubsetsGenerator_constant_new(PyTypeObject *type, PyObject *args, PyObject *) BASED_ON(SubsetsGenerator, "([constant=])") ALLOWS_EMPTY
{ PyTRY
    PyObject *varlist = NULL;

    if (!PyArg_ParseTuple(args, "|O:SubsetsGenerator_constant.__new__", &varlist))
      return PYNULL;

    TSubsetsGenerator_constant *gen = mlnew TSubsetsGenerator_constant();
    if (varlist && !(gen->varList = varListForReset(varlist))) {
      delete gen;
      return NULL;
    }

    gen->constant = CLONE(TVarList, gen->varList);
    return WrapNewOrange(gen, type);
  PyCATCH
}
/* ************ MINIMAL COMPLEXITY ************ */

#include "minimal_complexity.hpp"

ABSTRACT(IGConstructor, Orange)
C_CALL(IGBySorting, IGConstructor, "([examples, bound-attrs]) -/-> IG")

ABSTRACT(ColorIG, Orange)
C_CALL(ColorIG_MCF, ColorIG, "([IG]) -/-> ColoredIG")

C_CALL(FeatureByMinComplexity, FeatureInducer, "([examples, bound-attrs, name] [IGConstructor=, classifierFromIG=) -/-> Variable")

C_NAMED(ColoredIG, GeneralExampleClustering, "(ig=, colors=)")

PYCLASSCONSTANT_INT(FeatureByMinComplexity, NoCompletion, completion_no)
PYCLASSCONSTANT_INT(FeatureByMinComplexity, CompletionByDefault, completion_default)
PYCLASSCONSTANT_INT(FeatureByMinComplexity, CompletionByBayes, completion_bayes)

bool convertFromPython(PyObject *args, TIGNode &ign)
{ PyTRY
    PDiscDistribution inco, co;
    TExample *example;
    if (!PyArg_ParseTuple(args, "O&|O&O&:convertFromPython(IG)", ptr_Example, &example, ccn_DiscDistribution, &inco, ccn_DiscDistribution, &co))
      return false;

    ign.example = PExample(mlnew TExample(*example));

    if (inco)
      ign.incompatibility = inco.getReference();
    if (co)
      ign.compatibility = co.getReference();
    return true;
  PyCATCH_r(false);
}
      

bool convertFromPython(PyObject *args, PIG &ig)
{ if (!PyList_Check(args))
    PYERROR(PyExc_AttributeError, "invalid arguments (list expected)", false);

  ig=PIG(mlnew TIG());
  for(int i=0; i<PyList_Size(args); i++) {
    ig->nodes.push_back(TIGNode());
    if (!convertFromPython(PyList_GetItem(args, i), ig->nodes.back())) {
      ig=PIG();
      PYERROR(PyExc_AttributeError, "invalid list argument", false);
    }
  }

  return true;
}


PyObject *IG_new(PyTypeObject *type, PyObject *args, PyObject *) BASED_ON(Orange, "<see the manual>")
{ PyTRY
    PyObject *pyig;
    PIG ig;
    return PyArg_ParseTuple(args, "O:IG.new", &pyig) && convertFromPython(pyig, ig) ? WrapOrange(ig) : PYNULL;
  PyCATCH
}


PyObject *IG_native(PyObject *self) PYARGS(0, "() -> [(Example, [incompatibility-float], [compatibility-float])]")
{ PyTRY
    CAST_TO(TIG, graph);
  
    PyObject *result=PyList_New(graph->nodes.size());
    int i=0;
    ITERATE(vector<TIGNode>, ni, graph->nodes)
      PyList_SetItem(result, i++, Py_BuildValue("NNN", 
        Example_FromWrappedExample((*ni).example),
         // it's OK to wrap a reference - we're just copying it
        WrapNewOrange(mlnew TDiscDistribution((*ni).incompatibility), (PyTypeObject *)&PyOrDiscDistribution_Type),
        WrapNewOrange(mlnew TDiscDistribution((*ni).compatibility), (PyTypeObject *)&PyOrDiscDistribution_Type)
      ));

    return result;
  PyCATCH
}


PyObject *IG__reduce__(PyObject *self)
{
  PyTRY
    return Py_BuildValue("O(N)N", self->ob_type, IG_native(self), packOrangeDictionary(self));
  PyCATCH
}


PyObject *IG_normalize(PyObject *self) PYARGS(0, "() -> None")
{ PyTRY
    SELF_AS(TIG).normalize();
    RETURN_NONE;
  PyCATCH
}


PyObject *IG_make0or1(PyObject *self) PYARGS(0, "() -> None")
{ PyTRY
    SELF_AS(TIG).make0or1();
    RETURN_NONE;
  PyCATCH
}


PyObject *IG_complete(PyObject *self) PYARGS(0, "() -> None")
{ PyTRY
    SELF_AS(TIG).complete();
    RETURN_NONE;
  PyCATCH
}


PyObject *IG_removeEmpty(PyObject *self) PYARGS(0, "() -> None")
{ PyTRY
    SELF_AS(TIG).complete();
    RETURN_NONE;
  PyCATCH
}



PyObject *IGConstructor_call(PyObject *self, PyObject *args, PyObject *keywords) PYDOC("(examples, bound-attrs) -> IG")
{
  PyTRY
    NO_KEYWORDS

    PExampleGenerator egen;
    PyObject *boundList;
    int weight=0;
    if (!PyArg_ParseTuple(args, "O&O|O&", pt_ExampleGenerator, &egen, &boundList, pt_weightByGen(egen), &weight))
      PYERROR(PyExc_TypeError, "attribute error", PYNULL);

    TVarList boundset;
    if (!varListFromDomain(boundList, egen->domain, boundset))
      return PYNULL;

    return WrapOrange(SELF_AS(TIGConstructor)(egen, boundset, weight));
  PyCATCH
}



PyObject *ColorIG_call(PyObject *self, PyObject *args, PyObject *keywords) PYDOC("(ig) -> [int]")
{
  PyTRY
    NO_KEYWORDS

    PIG graph;
    return PyArg_ParseTuple(args, "O&:ColorIG.__call__", cc_IG, &graph) ? WrapOrange(SELF_AS(TColorIG)(graph)) : PYNULL;
  PyCATCH
}


/* ************ MINIMAL ERROR ******** */

#include "minimal_error.hpp"

C_CALL(FeatureByIM, FeatureInducer, "([examples, bound-attrs, name] [constructIM=, classifierFromIM=]) -/-> Variable")

ABSTRACT(IMConstructor, Orange)
C_CALL(IMBySorting, IMConstructor, "() | (examples, bound-attrs[[, free-attrs], weightID]) -/-> IM")
C_CALL(IMByIMByRows, IMConstructor, "() | (examples, bound-attrs[[, free-attrs], weightID]) -/-> IM")
C_CALL(IMByRelief, IMConstructor, "() | (examples, bound-attrs[[, free-attrs], weightID]) -/-> IM")

ABSTRACT(ClustersFromIM, Orange)
C_CALL(ClustersFromIMByAssessor, ClustersFromIM, "([IM] [minProfitProportion=, columnAssessor=, stopCriterion=]) -/-> IMClustering")

C_NAMED(IMClustering, Orange, "([im= clusters=, maxCluster=])")

BASED_ON(IMByRows, Orange)
NO_PICKLE(IMByRows)

ABSTRACT(IMByRowsConstructor, Orange)
C_CALL(IMByRowsBySorting, IMByRowsConstructor, "() | (examples, bound-attrs[[, free-attrs], weightID]) -/-> IMByRows")
C_CALL(IMByRowsByRelief, IMByRowsConstructor, "() | (examples, bound-attrs[[, free-attrs], weightID]) -/-> IMByRows")

ABSTRACT(IMByRowsPreprocessor, Orange)
C_CALL(IMBlurer, IMByRowsPreprocessor, "([IMByRows]) -> None")

C_CALL3(AssessIMQuality, AssessIMQuality, Orange, "([IM] -/-> float)")

ABSTRACT(StopIMClusteringByAssessor, Orange)
C_NAMED(StopIMClusteringByAssessor_noProfit, StopIMClusteringByAssessor, "([minProfitProportion=])")
C_NAMED(StopIMClusteringByAssessor_binary, StopIMClusteringByAssessor, "()")
C_NAMED(StopIMClusteringByAssessor_n, StopIMClusteringByAssessor, "(n=)")
C_NAMED(StopIMClusteringByAssessor_noBigChange, StopIMClusteringByAssessor, "()")

ABSTRACT(ColumnAssessor, Orange)
C_NAMED(ColumnAssessor_m, ColumnAssessor, "([m=])")
C_NAMED(ColumnAssessor_Laplace, ColumnAssessor, "()")
C_NAMED(ColumnAssessor_mf, ColumnAssessor, "([m=])")
C_NAMED(ColumnAssessor_N, ColumnAssessor, "()")
C_NAMED(ColumnAssessor_Relief, ColumnAssessor, "()")
C_NAMED(ColumnAssessor_Measure, ColumnAssessor, "(measure=)")
C_NAMED(ColumnAssessor_Kramer, ColumnAssessor, "()")

C_CALL(MeasureAttribute_IM, MeasureAttribute, "(constructIM=, columnAssessor=) | (attr, examples[, apriori] [,weightID]) -/-> (float, meas-type)")


PYCLASSCONSTANT_INT(FeatureByIM, NoCompletion, completion_no)
PYCLASSCONSTANT_INT(FeatureByIM, CompletionByDefault, completion_default)
PYCLASSCONSTANT_INT(FeatureByIM, CompletionByBayes, completion_bayes)


PyObject *IMConstructor_call(PyObject *self, PyObject *args, PyObject *keywords) PYDOC("(example, bound-attrs[, weightID]) -> IM")
{
  PyTRY
    NO_KEYWORDS

    PExampleGenerator egen;
    PyObject *boundList;
    int weightID = 0;
    if (PyArg_ParseTuple(args, "O&O|O&", pt_ExampleGenerator, &egen, &boundList, pt_weightByGen(egen), &weightID)) {
      TVarList boundset;
      if (!varListFromDomain(boundList, egen->domain, boundset))
        return PYNULL;

      PIM im=SELF_AS(TIMConstructor)(egen, boundset, weightID);
      return WrapOrange(im);
    }

    PyErr_Clear();

    PyObject *freeList;
    if (PyArg_ParseTuple(args, "O&OO|O&", pt_ExampleGenerator, &egen, &boundList, &freeList, pt_weightByGen(egen), &weightID)) {
      TVarList boundset;
      if (!varListFromDomain(boundList, egen->domain, boundset))
        return PYNULL;

      TVarList freeset;
      if (!varListFromDomain(freeList, egen->domain, freeset))
        return PYNULL;

      PIM im = SELF_AS(TIMConstructor)(egen, boundset, freeset, weightID);
      return WrapOrange(im);
    }

    PyErr_Clear();

    PIMByRows imbr;
    if (PyArg_ParseTuple(args, "O&", cc_IMByRows, &imbr))
      return WrapOrange(SELF_AS(TIMConstructor)(imbr));

    PYERROR(PyExc_TypeError, "invalid arguments -- examples, boundset and optional freeset and weight expected", PYNULL);
  PyCATCH
}



PyObject *IMByRowsConstructor_call(PyObject *self, PyObject *args, PyObject *keywords) PYDOC("(example, bound-attrs[, weightID]) -> IM")
{
  PyTRY
    NO_KEYWORDS

    PExampleGenerator egen;
    PyObject *boundList;
    int weightID=0;
    if (PyArg_ParseTuple(args, "O&O|O&", pt_ExampleGenerator, &egen, &boundList, pt_weightByGen(egen), &weightID)) {
      TVarList boundset;
      if (!varListFromDomain(boundList, egen->domain, boundset))
        return PYNULL;

      PIMByRows im=SELF_AS(TIMByRowsConstructor)(egen, boundset, weightID);
      return WrapOrange(im);
    }

    PyErr_Clear();

    PyObject *freeList;
    if (PyArg_ParseTuple(args, "O&OO|O&", pt_ExampleGenerator, &egen, &boundList, &freeList, pt_weightByGen(egen), &weightID)) {
      TVarList boundset;
      if (!varListFromDomain(boundList, egen->domain, boundset))
        return PYNULL;

      TVarList freeset;
      if (!varListFromDomain(freeList, egen->domain, freeset))
        return PYNULL;

      PIMByRows im=SELF_AS(TIMByRowsConstructor)(egen, boundset, freeset, weightID);
      return WrapOrange(im);
    }

    PYERROR(PyExc_TypeError, "invalid arguments -- examples, boundset and optional freeset and weight expected", PYNULL);
  PyCATCH
}




PyObject *IMByRowsPreprocessor_call(PyObject *self, PyObject *args, PyObject *keywords) PYDOC("(IMByRows) -> None")
{ 
  PyTRY
    NO_KEYWORDS
    
    PIMByRows pimbr;
    if (!PyArg_ParseTuple(args, "O&", cc_IMByRows, &pimbr))
      PYERROR(PyExc_TypeError, "IMByRows expected", PYNULL)

    SELF_AS(TIMByRowsPreprocessor)(pimbr);
    RETURN_NONE;
  PyCATCH
}


PyObject *Float2List(float *f, int size)
{ PyObject *dlist = PyList_New(size);
  for(int i = 0; i < size; i++)
    PyList_SetItem(dlist, i, PyFloat_FromDouble((double)*(f++)));
  return dlist;
}


bool List2Float(PyObject *l, float *&f, int &size)
{ if (!PyList_Check(l))