lib_learner.cpp

orange源码 数据挖掘技术

    PExampleGenerator egen;
    int references = 1;
    int negate = 0;
    if (!PyArg_ParseTuple(args, "O&|ii:Rule.__call__", &pt_ExampleGenerator, &egen, &references, &negate))
      return PYNULL;

    CAST_TO(TRule, rule)
    PExampleTable res = (*rule)(egen,(references?true:false),(negate?true:false));
    return WrapOrange(res);
  PyCATCH
}

PyObject *Rule_filterAndStore(PyObject *self, PyObject *args) PYARGS(METH_VARARGS, "(examples, weightID, targetClass)")
{
  PyTRY
    PExampleGenerator gen;
    int weightID = 0;
    int targetClass = -1;
    
    if (!PyArg_ParseTuple(args, "O&O&i:RuleEvaluator.call",  pt_ExampleGenerator, &gen, pt_weightByGen(gen), &weightID, &targetClass))
      return PYNULL;

    CAST_TO(TRule, rule);
    rule->filterAndStore(gen,weightID,targetClass);
    RETURN_NONE;
 PyCATCH
}

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

PyObject *RuleEvaluator__reduce__(PyObject *self)
{
  return callbackReduce(self, PyOrRuleEvaluator_Type);
}


PyObject *RuleEvaluator_call(PyObject *self, PyObject *args, PyObject *keywords) PYDOC("(rule, table, weightID, targetClass, apriori) -/-> (quality)")
{
  PyTRY
    NO_KEYWORDS

    PRule rule;
    PExampleGenerator gen;
    int weightID = 0;
    int targetClass = -1;
    PDistribution apriori;

    if (!PyArg_ParseTuple(args, "O&O&O&iO&:RuleEvaluator.call", cc_Rule, &rule, pt_ExampleGenerator, &gen, pt_weightByGen(gen), &weightID, &targetClass, cc_Distribution, &apriori))
      return PYNULL;
    CAST_TO(TRuleEvaluator, evaluator)
    float quality;
     
    quality = (*evaluator)(rule, gen, weightID, targetClass, apriori);
    return PyFloat_FromDouble(quality);
  PyCATCH
}

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

PyObject *RuleValidator__reduce__(PyObject *self)
{
  return callbackReduce(self, PyOrRuleValidator_Type);
}


PyObject *RuleValidator_call(PyObject *self, PyObject *args, PyObject *keywords) PYDOC("(rule, table, weightID, targetClass, apriori) -/-> (quality)")
{
  
  PyTRY
    NO_KEYWORDS

    PRule rule;
    PExampleGenerator gen;
    int weightID = 0;
    int targetClass = -1;
    PDistribution apriori;

    if (!PyArg_ParseTuple(args, "O&O&O&iO&:RuleValidator.call", cc_Rule, &rule, pt_ExampleGenerator, &gen, pt_weightByGen(gen), &weightID, &targetClass, cc_Distribution, &apriori))
      return PYNULL;
    CAST_TO(TRuleValidator, validator)

    bool valid;
    valid = (*validator)(rule, gen, weightID, targetClass, apriori);
    return PyInt_FromLong(valid?1:0);
  PyCATCH
}

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

PyObject *RuleCovererAndRemover__reduce__(PyObject *self)
{
  return callbackReduce(self, PyOrRuleCovererAndRemover_Type);
}


PyObject *RuleCovererAndRemover_call(PyObject *self, PyObject *args, PyObject *keywords) PYDOC("(rule, table, weightID, targetClass) -/-> (table,newWeight)")
{
  PyTRY
    NO_KEYWORDS

    PRule rule;
    PExampleGenerator gen;
    int weightID = 0;
    int newWeightID = 0;
    int targetClass = -1;

    if (!PyArg_ParseTuple(args, "O&O&O&i:RuleCovererAndRemover.call", cc_Rule, &rule, pt_ExampleGenerator, &gen, pt_weightByGen(gen), &weightID,&targetClass))
      return PYNULL;
    CAST_TO(TRuleCovererAndRemover, covererAndRemover)

    PExampleTable res = (*covererAndRemover)(rule, gen, weightID, newWeightID, targetClass);
    return Py_BuildValue("Ni", WrapOrange(res),newWeightID);
  PyCATCH
}

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

PyObject *RuleStoppingCriteria__reduce__(PyObject *self)
{
  return callbackReduce(self, PyOrRuleStoppingCriteria_Type);
}


PyObject *RuleStoppingCriteria_call(PyObject *self, PyObject *args, PyObject *keywords) PYDOC("(rulelist, rule, table, weightID) -/-> (table)")
{
  PyTRY
    NO_KEYWORDS

    PRuleList ruleList;
    PRule rule;
    PExampleGenerator gen;
    int weightID = 0;

    if (!PyArg_ParseTuple(args, "O&O&O&O&:RuleStoppingCriteria.call", cc_RuleList, &ruleList, cc_Rule, &rule, pt_ExampleGenerator, &gen, pt_weightByGen(gen), &weightID))
      return PYNULL;
    CAST_TO(TRuleStoppingCriteria, ruleStopping)

    bool stop = (*ruleStopping)(ruleList, rule, gen, weightID);
    return PyInt_FromLong(stop?1:0);
  PyCATCH
}

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

PyObject *RuleDataStoppingCriteria__reduce__(PyObject *self)
{
  return callbackReduce(self, PyOrRuleDataStoppingCriteria_Type);
}


PyObject *RuleDataStoppingCriteria_call(PyObject *self, PyObject *args, PyObject *keywords) PYDOC("(table, weightID, targetClass) -/-> (table)")
{
  PyTRY
    NO_KEYWORDS

    PExampleGenerator gen;
    int weightID = 0;
    int targetClass = -1;

    if (!PyArg_ParseTuple(args, "O&O&i:RuleDataStoppingCriteria.call", pt_ExampleGenerator, &gen, pt_weightByGen(gen), &weightID, &targetClass))
      return PYNULL;
    CAST_TO(TRuleDataStoppingCriteria, dataStopping)

    bool stop = (*dataStopping)(gen, weightID, targetClass);
    return PyInt_FromLong(stop?1:0);
  PyCATCH
}

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

PyObject *RuleFinder__reduce__(PyObject *self)
{
  return callbackReduce(self, PyOrRuleFinder_Type);
}


PyObject *RuleFinder_call(PyObject *self, PyObject *args, PyObject *keywords) PYDOC("(table, weightID, targetClass, baseRules) -/-> (rule)")
{
  PyTRY
    NO_KEYWORDS

    PExampleGenerator gen;
    int weightID = 0;
    int targetClass = -1;
    PRuleList baseRules;

    if (!PyArg_ParseTuple(args, "O&O&iO&:RuleFinder.call", pt_ExampleGenerator, &gen, pt_weightByGen(gen), &weightID, &targetClass, ccn_RuleList, &baseRules))
      return PYNULL;
    CAST_TO(TRuleFinder, finder)

    PRule res = (*finder)(gen, weightID, targetClass, baseRules);
    return WrapOrange(res);
  PyCATCH 
}

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

PyObject *RuleBeamRefiner__reduce__(PyObject *self)
{
  return callbackReduce(self, PyOrRuleBeamRefiner_Type);
}


PyObject *RuleBeamRefiner_call(PyObject *self, PyObject *args, PyObject *keywords) PYDOC("(rule, table, weightID, targetClass) -/-> (rules)")
{
  PyTRY
    NO_KEYWORDS

    PExampleGenerator gen;
    int weightID = 0;
    int targetClass = -1;
    PRule rule;

    if (!PyArg_ParseTuple(args, "O&O&O&i:RuleBeamRefiner.call", cc_Rule, &rule, pt_ExampleGenerator, &gen, pt_weightByGen(gen), &weightID, &targetClass))
      return PYNULL;
    CAST_TO(TRuleBeamRefiner, refiner)

    PRuleList res = (*refiner)(rule, gen, weightID, targetClass);
    return WrapOrange(res);
  PyCATCH
}

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

PyObject *RuleBeamInitializer__reduce__(PyObject *self)
{
  return callbackReduce(self, PyOrRuleBeamInitializer_Type);
}


PyObject *RuleBeamInitializer_call(PyObject *self, PyObject *args, PyObject *keywords) PYDOC("(table, weightID, targetClass, baseRules, evaluator, prior) -/-> (rules, bestRule)")
{
  PyTRY
    NO_KEYWORDS

    PExampleGenerator gen;
    PRuleList baseRules;
    PRuleEvaluator evaluator;
    PDistribution prior;
    PRule bestRule;
    int weightID = 0;
    int targetClass = -1;
    PRule rule;

    if (!PyArg_ParseTuple(args, "O&O&iO&O&O&:RuleBeamInitializer.call", pt_ExampleGenerator, &gen, pt_weightByGen(gen), &weightID, &targetClass, ccn_RuleList, &baseRules, cc_RuleEvaluator, &evaluator, cc_Distribution, &prior))
      return PYNULL;
    CAST_TO(TRuleBeamInitializer, initializer)

    PRuleList res = (*initializer)(gen, weightID, targetClass, baseRules, evaluator, prior, bestRule);
    return Py_BuildValue("NN", WrapOrange(res), WrapOrange(bestRule));
  PyCATCH
}

PyObject *RuleBeamCandidateSelector_new(PyTypeObject *type, PyObject *args