callback.cpp

orange源码 数据挖掘技术

  if (pyweights && (pyweights!=Py_None)) {
    if (!PyList_Check(pyweights) || (PyList_Size(pyweights)!=(int)node->branches->size()))
      raiseError("invalid result from __call__ (length of weight list should equal the number of branches)");
      
    for (int sz = 0, se = PyList_Size(pyweights); sz<se; sz++) {
      PyObject *li = PyList_GetItem(pyweights, sz);
      if (!PyInt_Check(li))
        raiseError("invalid weight list (int's expected).");
      newWeights.push_back(int(PyInt_AsLong(li)));
    }  
  }
  else
    newWeights.clear();

  Py_DECREF(res);

  return eglist;
}




bool TTreeStopCriteria_Python::operator()(PExampleGenerator gen, const int &weightID, PDomainContingency dcont)
{ 
  if (!gen)
    raiseError("invalid example generator");

  PyObject *args = Py_BuildValue("(NiN)", WrapOrange(gen), weightID, WrapOrange(dcont));
  PyObject *result=callCallback((PyObject *)myWrapper, args);
  Py_DECREF(args);

  bool res = bool(PyObject_IsTrue(result)!=0);
  Py_DECREF(result);
  return res;
}



int pt_DiscDistribution(PyObject *args, void *dist);

PTreeNode TTreeDescender_Python::operator()(PTreeNode node, const TExample &ex, PDiscDistribution &distr)
{ 
  PyObject *args = Py_BuildValue("(NN)", WrapOrange(node), Example_FromExampleCopyRef(ex));
  PyObject *result = callCallback((PyObject *)myWrapper, args);
  Py_DECREF(args);

  if (result == Py_None) {
    Py_DECREF(result);
    distr->clear();
    return PTreeNode();
  }
      
  PTreeNode newnode;
  distr = PDiscDistribution();
  if (PyOrTreeNode_Check(result))
    newnode = PyOrange_AsTreeNode(result);
  else if (!PyArg_ParseTuple(result, "O&|O&", cc_TreeNode, &newnode, pt_DiscDistribution, &distr)) {
    Py_DECREF(result);
    raiseError("invalid result from __call__");
  }

  Py_DECREF(result);
  return newnode;
}


bool TProgressCallback_Python::operator()(const float &f, POrange o)
{ 
  PyObject *args = Py_BuildValue("fN", f, WrapOrange(o));
  PyObject *result = callCallback((PyObject *)myWrapper, args);
  Py_DECREF(args);

  bool res = PyObject_IsTrue(result) != 0;
  Py_DECREF(result);
  return res;
}


PImputer TImputerConstruct_Python::operator()(PExampleGenerator eg, const int &weight)
{ 
  if (!eg)
    raiseError("invalid example generator");

  PyObject *args = Py_BuildValue("(Ni)", WrapOrange(POrange(eg)), weight);
  PyObject *res = callCallback((PyObject *)myWrapper, args);
  Py_DECREF(args);

  if (!PyOrImputer_Check(res)) 
    raiseError("__call__ is expected to return something derived from Imputer");

  PImputer imp = PyOrange_AsImputer(res);
  Py_DECREF(res);
  return imp;
}


TExample *TImputer_Python::operator()(TExample &example)
{
  PyObject *args = Py_BuildValue("(Ni)", Example_FromExampleCopyRef(example), 0);
  PyObject *result = callCallback((PyObject *)myWrapper, args);
  Py_DECREF(args);

  if (!PyOrExample_Check(result))
    raiseError("__call__ is expected to return an instance of Example");

  TExample *res = CLONE(TExample, PyExample_AS_Example(result));
  Py_DECREF(result);
  return res;
}

float TRuleEvaluator_Python::operator()(PRule rule, PExampleTable table, const int &weightID, const int &targetClass, PDistribution apriori) const
{
  if (!table)
    raiseError("invalid example table");
  if (!rule)
    raiseError("invalid rule");
  if (!apriori)
    raiseError("invalid prior distribution");

  PyObject *args = Py_BuildValue("(NNiiN)", WrapOrange(rule), WrapOrange(table), weightID, targetClass, WrapOrange(apriori));
  PyObject *result=callCallback((PyObject *)myWrapper, args);
  Py_DECREF(args);

  if (!PyFloat_Check(result))
    raiseError("__call__ is expected to return a float value.");
  float res = PyFloat_AsDouble(result);
  Py_DECREF(result);
  return res;
}

bool TRuleValidator_Python::operator()(PRule rule, PExampleTable table, const int &weightID, const int &targetClass, PDistribution apriori) const
{
  if (!table)
    raiseError("invalid example table");
  if (!rule)
    raiseError("invalid rule");
  if (!apriori)
    raiseError("invalid prior distribution");

  PyObject *args = Py_BuildValue("(NNiiN)", WrapOrange(rule), WrapOrange(table), weightID, targetClass, WrapOrange(apriori));
  PyObject *result=callCallback((PyObject *)myWrapper, args);
  Py_DECREF(args);

  if (!PyBool_Check(result))
    raiseError("__call__ is expected to return a Boolean value.");
  bool res = bool(PyObject_IsTrue(result)!=0);
  Py_DECREF(result);
  return res;
}

PExampleTable TRuleCovererAndRemover_Python::operator()(PRule rule, PExampleTable table, const int &weightID, int &newWeightID, const int &targetClass) const
{
  if (!table)
    raiseError("invalid example table");
  if (!rule)
    raiseError("invalid rule");

  PyObject *args = Py_BuildValue("(NNii)", WrapOrange(rule), WrapOrange(table), weightID, targetClass);
  PyObject *result = callCallback((PyObject *)myWrapper, args);
  Py_DECREF(args);

  PExampleGenerator gen; 
  if (!PyArg_ParseTuple(result, "O&O&", pt_ExampleGenerator, &gen, pt_weightByGen(gen), &newWeightID))
    raiseError("__call__ is expected to return a tuple: (example table, new weight ID)");
  Py_DECREF(result);
  return gen;
}

bool TRuleStoppingCriteria_Python::operator()(PRuleList ruleList, PRule rule, PExampleTable table, const int &weightID) const
{
  if (!ruleList)
    raiseError("invalid rule list");
  if (!table)
    raiseError("invalid example table");
  if (!rule)
    raiseError("invalid rule");

  PyObject *args = Py_BuildValue("(NNNi)", WrapOrange(ruleList), WrapOrange(rule), WrapOrange(table), weightID);
  PyObject *result = callCallback((PyObject *)myWrapper, args);
  Py_DECREF(args);

  if (!PyBool_Check(result))
    raiseError("__call__ is expected to return a Boolean value.");
  bool res = bool(PyObject_IsTrue(result)!=0);
  Py_DECREF(result);
  return res;
}

bool TRuleDataStoppingCriteria_Python::operator()(PExampleTable table, const int &weightID, const int &targetClass) const
{
  if (!table)
    raiseError("invalid example table");

  PyObject *args = Py_BuildValue("(Nii)", WrapOrange(table), weightID, targetClass);
  PyObject *result=callCallback((PyObject *)myWrapper, args);
  Py_DECREF(args);

  if (!PyBool_Check(result))
    raiseError("__call__ is expected to return a Boolean value.");
  bool res = bool(PyObject_IsTrue(result)!=0);
  Py_DECREF(result);
  return res;
}

PRule TRuleFinder_Python::operator ()(PExampleTable table, const int &weightID, const int &targetClass, PRuleList baseRules)
{
  if (!table)
    raiseError("invalid example table");

  PyObject *args = Py_BuildValue("(NiiN)", WrapOrange(table), weightID, targetClass, WrapOrange(baseRules));
  PyObject *result = callCallback((PyObject *)myWrapper, args);
  Py_DECREF(args);

  if (!PyOrRule_Check(result))
    raiseError("__call__ is expected to return a rule.");
  PRule res = PyOrange_AsRule(result);
  Py_DECREF(result);
  return res;
}

PRuleList TRuleBeamRefiner_Python::operator ()(PRule rule, PExampleTable table, const int &weightID, const int &targetClass)
{
  if (!table)
    raiseError("invalid example table");
  if (!rule)
    raiseError("invalid rule");

  PyObject *args = Py_BuildValue("(NNii)", WrapOrange(rule), WrapOrange(table), weightID, targetClass);
  PyObject *result = callCallback((PyObject *)myWrapper, args);
  Py_DECREF(args);

  if (!PyOrRuleList_Check(result))
    raiseError("__call__ is expected to return a list of rules.");
  PRuleList res = PyOrange_AsRuleList(result);
  Py_DECREF(result);
  return res;
}

PRuleList TRuleBeamInitializer_Python::operator ()(PExampleTable table, const int &weightID, const int &targetClass, PRuleList baseRules, PRuleEvaluator evaluator, PDistribution prior, PRule &bestRule)
{
  if (!table)
    raiseError("invalid example table");
  if (!evaluator)
    raiseError("invalid evaluator function");
  if (!prior)
    raiseError("invalid prior distribution");

  PyObject *args = Py_BuildValue("(NiiNNNN)", WrapOrange(table), weightID, targetClass, WrapOrange(baseRules), WrapOrange(evaluator), WrapOrange(prior), WrapOrange(bestRule));
  PyObject *result = callCallback((PyObject *)myWrapper, args);
  Py_DECREF(args);

  if (!PyOrRuleList_Check(result))
    raiseError("__call__ is expected to return a list of rules.");
  PRule res = PyOrange_AsRuleList(result);
  Py_DECREF(result);
  return res;
}

PRuleList TRuleBeamCandidateSelector_Python::operator ()(PRuleList &existingRules, PExampleTable table, const int &weightID)
{
  if (!table)
    raiseError("invalid example table");
  if (!existingRules)
    raiseError("invalid existing rules");

  PyObject *args = Py_BuildValue("(NNi)", WrapOrange(existingRules), WrapOrange(table), weightID);
  PyObject *result = callCallback((PyObject *)myWrapper, args);
  Py_DECREF(args);

  PRuleList candidates; 
  if (!PyArg_ParseTuple(result, "O&O&", cc_RuleList, &candidates, cc_RuleList, &existingRules))
    raiseError("__call__ is expected to return a tuple: (candidate rules, remaining rules)");
  Py_DECREF(result);
  return candidates;
}

void TRuleBeamFilter_Python::operator ()(PRuleList &rules, PExampleTable table, const int &weightID)
{
  if (!table)
    raiseError("invalid example table");
  if (!rules)
    raiseError("invalid existing rules");

  PyObject *args = Py_BuildValue("(NNi)", WrapOrange(rules), WrapOrange(table), weightID);
  PyObject *result = callCallback((PyObject *)myWrapper, args);
  Py_DECREF(args);

  if (!PyOrRuleList_Check(result))
    raiseError("__call__ is expected to return a list of rules.");
  rules = PyOrange_AsRuleList(result);
  Py_DECREF(result);
}

PRuleClassifier TRuleClassifierConstructor_Python::operator()(PRuleList rules, PExampleTable table, const int &weightID)
{ if (!rules)
    raiseError("invalid set of rules");
  if (!table)  
    raiseError("invalid example table");

  PyObject *args = Py_BuildValue("(NNi)", WrapOrange(rules), WrapOrange(table), weightID);
  PyObject *result = callCallback((PyObject *)myWrapper, args);
  Py_DECREF(args);

  if (result==Py_None) {
    Py_DECREF(result);
    return PRuleClassifier();
  }

  if (!PyOrRuleClassifier_Check(result))
    raiseError("__call__ is expected to return a rule classifier."); 
  PRuleClassifier res = PyOrange_AsRuleClassifier(result);
  Py_DECREF(result); 
  return res;
}


float TKernelFunc_Python::operator ()(const TExample &e1, const TExample &e2){
	PyObject *args=Py_BuildValue("(NN)", Example_FromExampleCopyRef(e1), Example_FromExampleCopyRef(e2));
	PyObject *result=callCallback((PyObject *)myWrapper, args);
	Py_DECREF(args);
	float res=PyFloat_AsDouble(result);
	Py_DECREF(result);
	return res;
}


PExamplesDistance TExamplesDistanceConstructor_Python::operator ()(PExampleGenerator eg, const int &wei, PDomainDistributions dd, PDomainBasicAttrStat das) const
{
	PyObject *args=Py_BuildValue("(NiNN)", WrapOrange(eg), wei, WrapOrange(dd), WrapOrange(das));
	PyObject *result=callCallback((PyObject *)myWrapper, args);
	Py_DECREF(args);
  PExamplesDistance res = PyOrange_AsExamplesDistance(result);
	Py_DECREF(result);
	return res;
}



float TExamplesDistance_Python::operator()(const TExample &e1, const TExample &e2) const
{
	PyObject *args=Py_BuildValue("(NN)", Example_FromExampleCopyRef(e1), Example_FromExampleCopyRef(e2));
	PyObject *result=callCallback((PyObject *)myWrapper, args);
	Py_DECREF(args);
	float res=PyFloat_AsDouble(result);
	Py_DECREF(result);
	return res;
}

/*
PIM TConstructIM_Python::operator()(PExampleGenerator gen, const vector<bool> &bound, const TVarList &boundSet, const vector<bool> &free, const int &weightID)
{ if (!gen)
    raiseError("invalid example generator");

  PyObject *boundList = PyList_New(0);
  PyObject *freeList = PyList_New(0);
  vector<bool>::const_iterator bi(bound.begin()), fi(free.begin());

  const_PITERATE(TVarList, vi, gen->domain->attributes) {
    PyObject *m = WrapOrange(*vi);
    if (*(bi++))
      PyList_Append(boundList, m);
    if (*(fi++))
      PyList_Append(freeList, m);
    Py_DECREF(m);
  }

  PyObject *args = Py_BuildValue("(NNNi)", WrapOrange(gen), boundList, freeList, weightID);
  PyObject *res = callCallback((PyObject *)myWrapper, args);
  Py_DECREF(args);

  if (!PyOrIM_Check(res))
    raiseError("invalid result from __call__");

  PIM im = PyOrange_AsIM(res);
  Py_DECREF(res);
  return im;
}
*/