Changeset 7223:66b5d9ea16c2 in orange


Ignore:
Timestamp:
02/02/11 18:24:15 (3 years ago)
Author:
matija <matija.polajnar@…>
Branch:
default
Convert:
7d3c914985deb23600c33cbacd6a39aae8d6d903
Message:

An incomplete refactoring of rule induction.

Location:
orange
Files:
1 added
3 edited

Legend:

Unmodified
Added
Removed
  • orange/orngABCN2.py

    r6652 r7223  
    22The main learner class is ABCN2. The first few classes are some variants of ABCN2 with reasonable settings.  """ 
    33 
    4 import orange 
    5 import orngCN2 
     4import Orange.core 
     5import Orange.classification.rules 
    66from orngABML import * 
    77import operator 
     
    1313# default classifier with pre-  # 
    1414# defined output  class         # 
    15 class DefaultLearner(orange.Learner): 
     15class DefaultLearner(Orange.core.Learner): 
    1616    def __init__(self,defaultValue = None): 
    1717        self.defaultValue = defaultValue 
    1818    def __call__(self,examples,weightID=0): 
    19         return orange.DefaultClassifier(self.defaultValue,defaultDistribution = orange.Distribution(examples.domain.classVar,examples,weightID)) 
     19        return Orange.core.DefaultClassifier(self.defaultValue,defaultDistribution = Orange.core.Distribution(examples.domain.classVar,examples,weightID)) 
    2020 
    2121 
    2222# Main ABCN2 class 
    23 class ABCN2(orange.RuleLearner): 
     23class ABCN2(Orange.core.RuleLearner): 
    2424    """This is implementation of ABCN2 + EVC as evaluation + LRC classification. 
    2525    """ 
     
    7575        self.postpruning = postpruning 
    7676        # rule finder 
    77         self.ruleFinder = orange.RuleBeamFinder() 
    78         self.ruleFilter = orange.RuleBeamFilter_Width(width=width) 
     77        self.ruleFinder = Orange.core.RuleBeamFinder() 
     78        self.ruleFilter = Orange.core.RuleBeamFilter_Width(width=width) 
    7979        self.ruleFilter_arguments = ABBeamFilter(width=width) 
    8080        if max_rule_complexity - 1 < 0: 
    8181            max_rule_complexity = 10 
    82         self.ruleFinder.ruleStoppingValidator = orange.RuleValidator_LRS(alpha = 1.0, min_quality = 0., max_rule_complexity = max_rule_complexity - 1, min_coverage=min_coverage) 
    83         self.refiner = orange.RuleBeamRefiner_Selector() 
    84         self.refiner_arguments = SelectorAdder(discretizer = orange.EntropyDiscretization(forceAttribute = 1, 
     82        self.ruleFinder.ruleStoppingValidator = Orange.core.RuleValidator_LRS(alpha = 1.0, min_quality = 0., max_rule_complexity = max_rule_complexity - 1, min_coverage=min_coverage) 
     83        self.refiner = Orange.core.RuleBeamRefiner_Selector() 
     84        self.refiner_arguments = SelectorAdder(discretizer = Orange.core.EntropyDiscretization(forceAttribute = 1, 
    8585                                                                                           maxNumberOfIntervals = 2)) 
    8686        self.prune_arguments = prune_arguments 
    8787        # evc evaluator 
    88         evdGet = orange.EVDistGetter_Standard() 
    89         self.ruleFinder.evaluator = orange.RuleEvaluator_mEVC(m=m, evDistGetter = evdGet, min_improved = min_improved, min_improved_perc = min_improved_perc) 
     88        evdGet = Orange.core.EVDistGetter_Standard() 
     89        self.ruleFinder.evaluator = Orange.core.RuleEvaluator_mEVC(m=m, evDistGetter = evdGet, min_improved = min_improved, min_improved_perc = min_improved_perc) 
    9090        self.ruleFinder.evaluator.returnExpectedProb = True 
    9191        self.ruleFinder.evaluator.optimismReduction = opt_reduction 
    9292        self.ruleFinder.evaluator.ruleAlpha = rule_sig 
    9393        self.ruleFinder.evaluator.attributeAlpha = att_sig 
    94         self.ruleFinder.evaluator.validator = orange.RuleValidator_LRS(alpha = 1.0, min_quality = min_quality, min_coverage=min_coverage, max_rule_complexity = max_rule_complexity - 1) 
     94        self.ruleFinder.evaluator.validator = Orange.core.RuleValidator_LRS(alpha = 1.0, min_quality = min_quality, min_coverage=min_coverage, max_rule_complexity = max_rule_complexity - 1) 
    9595 
    9696        # learn stopping criteria 
    9797        self.ruleStopping = None 
    98         self.dataStopping = orange.RuleDataStoppingCriteria_NoPositives() 
     98        self.dataStopping = Orange.core.RuleDataStoppingCriteria_NoPositives() 
    9999        # evd fitting 
    100100        self.evd_creator = EVDFitter(self,n=nsampling) 
     
    114114            progress.start = 0.0 
    115115            progress.end = 0.0 
    116             distrib = orange.Distribution(examples.domain.classVar, examples, weightID) 
     116            distrib = Orange.core.Distribution(examples.domain.classVar, examples, weightID) 
    117117            distrib.normalize() 
    118118         
    119119        # we begin with an empty set of rules 
    120         all_rules = orange.RuleList() 
     120        all_rules = Orange.core.RuleList() 
    121121 
    122122        # th en, iterate through all classes and learn rule for each class separately 
     
    131131 
    132132            # rules for this class only 
    133             rules, arg_rules = orange.RuleList(), orange.RuleList() 
     133            rules, arg_rules = Orange.core.RuleList(), Orange.core.RuleList() 
    134134 
    135135            # create dichotomous class 
     
    158158                rule = self.learn_argumented_rule(ae, dich_data, weightID) # target class is always first class (0) 
    159159                if not progress: 
    160                     print "learned rule", orngCN2.ruleToString(rule) 
     160                    print "learned rule", Orange.classification.rules.ruleToString(rule) 
    161161                if rule: 
    162162                    arg_rules.append(rule) 
     
    182182                        break 
    183183                    if not progress: 
    184                         print "rule learned: ", orngCN2.ruleToString(rule), rule.quality 
     184                        print "rule learned: ", Orange.classification.rules.ruleToString(rule), rule.quality 
    185185                    dich_data = self.remove_covered_examples(rule, dich_data, weightID) 
    186186                    if progress: 
     
    234234    def prepare_settings(self, examples, weightID, cl_i, progress): 
    235235        # apriori distribution 
    236         self.apriori = orange.Distribution(examples.domain.classVar,examples,weightID) 
     236        self.apriori = Orange.core.Distribution(examples.domain.classVar,examples,weightID) 
    237237         
    238238        # prepare covering mechanism 
     
    263263        (newDomain, targetVal) = createDichotomousClass(examples.domain, examples.domain.classVar, str(cl), negate=0) 
    264264        newDomainmetas = newDomain.getmetas() 
    265         newDomain.addmeta(orange.newmetaid(), examples.domain.classVar) # old class as meta 
     265        newDomain.addmeta(Orange.core.newmetaid(), examples.domain.classVar) # old class as meta 
    266266        dichData = examples.select(newDomain) 
    267267        if self.argumentID: 
     
    287287            sorted.sort(lambda x,y: -cmp(x[self.argumentID].value.positiveArguments[0].quality, 
    288288                                         y[self.argumentID].value.positiveArguments[0].quality)) 
    289             return orange.ExampleTable(examples.domain, sorted) 
     289            return Orange.core.ExampleTable(examples.domain, sorted) 
    290290        else: 
    291291            return None 
     
    305305        if hasattr(self.ruleFinder.evaluator, "bestRule"): 
    306306            self.ruleFinder.evaluator.bestRule = None 
    307         rule = self.ruleFinder(examples,weightID,0,orange.RuleList()) 
     307        rule = self.ruleFinder(examples,weightID,0,Orange.core.RuleList()) 
    308308        if hasattr(self.ruleFinder.evaluator, "bestRule") and self.ruleFinder.evaluator.returnExpectedProb: 
    309309            rule = self.ruleFinder.evaluator.bestRule 
     
    323323    def change_domain(self, rule, cl, examples, weightID): 
    324324        rule.examples = rule.examples.select(examples.domain) 
    325         rule.classDistribution = orange.Distribution(rule.examples.domain.classVar,rule.examples,weightID) # adapt distribution 
    326         rule.classifier = orange.DefaultClassifier(cl) # adapt classifier 
    327         rule.filter = orange.Filter_values(domain = examples.domain, 
     325        rule.classDistribution = Orange.core.Distribution(rule.examples.domain.classVar,rule.examples,weightID) # adapt distribution 
     326        rule.classifier = Orange.core.DefaultClassifier(cl) # adapt classifier 
     327        rule.filter = Orange.core.Filter_values(domain = examples.domain, 
    328328                                        conditions = rule.filter.conditions) 
    329329        if hasattr(rule, "learner") and hasattr(rule.learner, "arg_example"): 
    330             rule.learner.arg_example = orange.Example(examples.domain, rule.learner.arg_example) 
     330            rule.learner.arg_example = Orange.core.Example(examples.domain, rule.learner.arg_example) 
    331331        return rule 
    332332 
     
    335335 
    336336    def add_sub_rules_call(self, rules, examples, weightID): 
    337         apriori = orange.Distribution(examples.domain.classVar,examples,weightID) 
    338         newRules = orange.RuleList() 
     337        apriori = Orange.core.Distribution(examples.domain.classVar,examples,weightID) 
     338        newRules = Orange.core.RuleList() 
    339339        for r in rules: 
    340340            newRules.append(r) 
     
    342342        # loop through rules 
    343343        for r in rules: 
    344             tmpList = orange.RuleList() 
     344            tmpList = Orange.core.RuleList() 
    345345            tmpRle = r.clone() 
    346346            tmpRle.filter.conditions = r.filter.conditions[:r.requiredConditions] # do not split argument 
     
    350350            tmpList.append(tmpRle) 
    351351            while tmpList and len(tmpList[0].filter.conditions) <= len(r.filter.conditions): 
    352                 tmpList2 = orange.RuleList() 
     352                tmpList2 = Orange.core.RuleList() 
    353353                for tmpRule in tmpList: 
    354354                    # evaluate tmpRule 
     
    358358                    self.ruleFinder.evaluator.returnExpectedProb = oldREP 
    359359                    # if rule not in rules already, add it to the list 
    360                     if not True in [orngCN2.rules_equal(ri,tmpRule) for ri in newRules] and len(tmpRule.filter.conditions)>0 and tmpRule.quality > apriori[r.classifier.defaultVal]/apriori.abs: 
     360                    if not True in [Orange.classification.rules.rules_equal(ri,tmpRule) for ri in newRules] and len(tmpRule.filter.conditions)>0 and tmpRule.quality > apriori[r.classifier.defaultVal]/apriori.abs: 
    361361                        newRules.append(tmpRule) 
    362362                    # create new tmpRules, set parent Rule, append them to tmpList2 
    363                     if not True in [orngCN2.rules_equal(ri,tmpRule) for ri in newRules]: 
     363                    if not True in [Orange.classification.rules.rules_equal(ri,tmpRule) for ri in newRules]: 
    364364                        for c in r.filter.conditions: 
    365365                            tmpRule2 = tmpRule.clone() 
     
    375375 
    376376    def init_pos_args(self, ae, examples, weightID): 
    377         pos_args = orange.RuleList() 
     377        pos_args = Orange.core.RuleList() 
    378378        # prepare arguments 
    379379        for p in ae[self.argumentID].value.positiveArguments: 
    380             new_arg = orange.Rule(filter=ArgFilter(argumentID = self.argumentID, 
     380            new_arg = Orange.core.Rule(filter=ArgFilter(argumentID = self.argumentID, 
    381381                                                   filter = self.newFilter_values(p.filter)), 
    382382                                                   complexity = 0) 
     
    408408                p.filter.filter.conditions.extend(pruned_conditions) 
    409409                # if argument does not contain all unspecialized reasons, add those reasons with minimum values 
    410                 at_oper_pairs = [(c.position, c.oper) for c in p.filter.conditions if type(c) == orange.ValueFilter_continuous] 
     410                at_oper_pairs = [(c.position, c.oper) for c in p.filter.conditions if type(c) == Orange.core.ValueFilter_continuous] 
    411411                for u in unspec_conditions: 
    412412                    if not (u.position, u.oper) in at_oper_pairs: 
     
    436436 
    437437    def newFilter_values(self, filter): 
    438         newFilter = orange.Filter_values() 
     438        newFilter = Orange.core.Filter_values() 
    439439        newFilter.conditions = filter.conditions[:] 
    440440        newFilter.domain = filter.domain 
     
    452452        if not allowed_conditions: 
    453453            return [] 
    454         cn2_learner = orngCN2.CN2UnorderedLearner() 
    455         cn2_learner.ruleFinder = orange.RuleBeamFinder() 
     454        cn2_learner = Orange.classification.rules.CN2UnorderedLearner() 
     455        cn2_learner.ruleFinder = Orange.core.RuleBeamFinder() 
    456456        cn2_learner.ruleFinder.refiner = SelectorArgConditions(crit_example, allowed_conditions) 
    457         cn2_learner.ruleFinder.evaluator = orngCN2.mEstimate(self.ruleFinder.evaluator.m) 
    458         rule = cn2_learner.ruleFinder(examples,weightID,0,orange.RuleList()) 
     457        cn2_learner.ruleFinder.evaluator = Orange.classification.rules.mEstimate(self.ruleFinder.evaluator.m) 
     458        rule = cn2_learner.ruleFinder(examples,weightID,0,Orange.core.RuleList()) 
    459459        return rule.filter.conditions 
    460460 
     
    478478# *********************** # 
    479479 
    480 class ABBeamFilter(orange.RuleBeamFilter): 
     480class ABBeamFilter(Orange.core.RuleBeamFilter): 
    481481    """ ABBeamFilter: Filters beam; 
    482482        - leaves first N rules (by quality) 
     
    488488 
    489489    def __call__(self,rulesStar,examples,weightID): 
    490         newStar=orange.RuleList() 
     490        newStar=Orange.core.RuleList() 
    491491        rulesStar.sort(lambda x,y: -cmp(x.quality,y.quality)) 
    492492        argsNum=0 
     
    550550 
    551551    def conditionIndex(c): 
    552         if type(c) == orange.ValueFilter_continuous: 
    553             if (c.oper == orange.ValueFilter_continuous.GreaterEqual or 
    554                 c.oper == orange.ValueFilter_continuous.Greater): 
     552        if type(c) == Orange.core.ValueFilter_continuous: 
     553            if (c.oper == Orange.core.ValueFilter_continuous.GreaterEqual or 
     554                c.oper == Orange.core.ValueFilter_continuous.Greater): 
    555555                return 5# 0101 
    556             elif (c.oper == orange.ValueFilter_continuous.LessEqual or 
    557                   c.oper == orange.ValueFilter_continuous.Less): 
     556            elif (c.oper == Orange.core.ValueFilter_continuous.LessEqual or 
     557                  c.oper == Orange.core.ValueFilter_continuous.Less): 
    558558                return 3 # 0011 
    559559            else: 
     
    581581    oneSelectorToCover = staticmethod(oneSelectorToCover)                  
    582582 
    583 class SelectorAdder(orange.RuleBeamRefiner): 
     583class SelectorAdder(Orange.core.RuleBeamRefiner): 
    584584    """ Selector adder, this function is a refiner function: 
    585585       - refined rules are not consistent with any of negative arguments. """ 
    586586    def __init__(self, example=None, notAllowedSelectors=[], argumentID = None, 
    587                  discretizer = orange.EntropyDiscretization(forceAttribute=True)): 
     587                 discretizer = Orange.core.EntropyDiscretization(forceAttribute=True)): 
    588588        # required values - needed values of attributes 
    589589        self.example = example 
     
    594594    def __call__(self, oldRule, data, weightID, targetClass=-1): 
    595595        inNotAllowedSelectors = ruleCoversArguments(self.notAllowedSelectors) 
    596         newRules = orange.RuleList() 
     596        newRules = Orange.core.RuleList() 
    597597 
    598598        # get positive indices (selectors already in the rule) 
     
    616616            if ind == 1:  
    617617                continue 
    618             if data.domain[i].varType == orange.VarTypes.Discrete and not negativeIndices[i]==1: # DISCRETE attribute 
     618            if data.domain[i].varType == Orange.core.VarTypes.Discrete and not negativeIndices[i]==1: # DISCRETE attribute 
    619619                if self.example: 
    620620                    values = [self.example[i]] 
     
    623623                for v in values: 
    624624                    tempRule = oldRule.clone() 
    625                     tempRule.filter.conditions.append(orange.ValueFilter_discrete(position = i, 
    626                                                                                   values = [orange.Value(data.domain[i],v)], 
     625                    tempRule.filter.conditions.append(Orange.core.ValueFilter_discrete(position = i, 
     626                                                                                  values = [Orange.core.Value(data.domain[i],v)], 
    627627                                                                                  acceptSpecial=0)) 
    628628                    tempRule.complexity += 1 
     
    631631                    if len(tempRule.examples)<len(oldRule.examples): 
    632632                        newRules.append(tempRule) 
    633             elif data.domain[i].varType == orange.VarTypes.Continuous and not negativeIndices[i]==7: # CONTINUOUS attribute 
     633            elif data.domain[i].varType == Orange.core.VarTypes.Continuous and not negativeIndices[i]==7: # CONTINUOUS attribute 
    634634                try: 
    635635                    at = data.domain[i] 
     
    642642                        #LESS 
    643643                        if not negativeIndices[i]==3: 
    644                             tempRule = self.getTempRule(oldRule,i,orange.ValueFilter_continuous.LessEqual,p,targetClass,3) 
     644                            tempRule = self.getTempRule(oldRule,i,Orange.core.ValueFilter_continuous.LessEqual,p,targetClass,3) 
    645645                            if len(tempRule.examples)<len(oldRule.examples) and self.example[i]<=p:# and not inNotAllowedSelectors(tempRule): 
    646646                                newRules.append(tempRule) 
    647647                        #GREATER 
    648648                        if not negativeIndices[i]==5: 
    649                             tempRule = self.getTempRule(oldRule,i,orange.ValueFilter_continuous.Greater,p,targetClass,5) 
     649                            tempRule = self.getTempRule(oldRule,i,Orange.core.ValueFilter_continuous.Greater,p,targetClass,5) 
    650650                            if len(tempRule.examples)<len(oldRule.examples) and self.example[i]>p:# and not inNotAllowedSelectors(tempRule): 
    651651                                newRules.append(tempRule) 
     
    658658        tempRule = oldRule.clone() 
    659659 
    660         tempRule.filter.conditions.append(orange.ValueFilter_continuous(position=pos, 
     660        tempRule.filter.conditions.append(Orange.core.ValueFilter_continuous(position=pos, 
    661661                                                                        oper=oper, 
    662662                                                                        ref=ref, 
     
    677677# This filter is the ugliest code ever! Problem is with Orange, I had some problems with inheriting deepCopy 
    678678# I should take another look at it. 
    679 class ArgFilter(orange.Filter): 
     679class ArgFilter(Orange.core.Filter): 
    680680    """ This class implements AB-covering principle. """ 
    681     def __init__(self, argumentID=None, filter = orange.Filter_values()): 
     681    def __init__(self, argumentID=None, filter = Orange.core.Filter_values()): 
    682682        self.filter = filter 
    683683        self.indices = getattr(filter,"indices",[]) 
     
    728728    def deepCopy(self): 
    729729        newFilter = ArgFilter(argumentID=self.argumentID) 
    730         newFilter.filter = orange.Filter_values() #self.filter.deepCopy() 
     730        newFilter.filter = Orange.core.Filter_values() #self.filter.deepCopy() 
    731731        newFilter.filter.conditions = self.filter.conditions[:] 
    732732        newFilter.domain = self.filter.domain 
     
    741741 
    742742 
    743 class SelectorArgConditions(orange.RuleBeamRefiner): 
     743class SelectorArgConditions(Orange.core.RuleBeamRefiner): 
    744744    """ Selector adder, this function is a refiner function: 
    745745       - refined rules are not consistent with any of negative arguments. """ 
     
    751751    def __call__(self, oldRule, data, weightID, targetClass=-1): 
    752752        if len(oldRule.filter.conditions) >= len(self.allowed_selectors): 
    753             return orange.RuleList() 
    754         newRules = orange.RuleList() 
     753            return Orange.core.RuleList() 
     754        newRules = Orange.core.RuleList() 
    755755        for c in self.allowed_selectors: 
    756756            # normal condition 
     
    772772                for v in values: 
    773773                    tempRule = oldRule.clone() 
    774                     tempRule.filter.conditions.append(orange.ValueFilter_continuous(position=c.position, 
     774                    tempRule.filter.conditions.append(Orange.core.ValueFilter_continuous(position=c.position, 
    775775                                                                                    oper=c.oper, 
    776776                                                                                    ref=float(v), 
     
    782782##        print " NEW RULES " 
    783783##        for r in newRules: 
    784 ##            print orngCN2.ruleToString(r) 
     784##            print Orange.classification.rules.ruleToString(r) 
    785785        for r in newRules: 
    786786            r.parentRule = oldRule 
    787 ##            print orngCN2.ruleToString(r) 
     787##            print Orange.classification.rules.ruleToString(r) 
    788788        return newRules 
    789789 
     
    793793# ********************** # 
    794794 
    795 class CovererAndRemover_Prob(orange.RuleCovererAndRemover): 
     795class CovererAndRemover_Prob(Orange.core.RuleCovererAndRemover): 
    796796    """ This class impements probabilistic covering. """ 
    797797 
    798798    def __init__(self, examples, weightID, targetClass, apriori): 
    799799        self.bestRule = [None]*len(examples) 
    800         self.probAttribute = orange.newmetaid() 
     800        self.probAttribute = Orange.core.newmetaid() 
    801801        self.aprioriProb = apriori[targetClass]/apriori.abs 
    802802        examples.addMetaAttribute(self.probAttribute, self.aprioriProb) 
    803         examples.domain.addmeta(self.probAttribute, orange.FloatVariable("Probs")) 
     803        examples.domain.addmeta(self.probAttribute, Orange.core.FloatVariable("Probs")) 
    804804 
    805805    def getBestRules(self, currentRules, examples, weightID): 
    806         bestRules = orange.RuleList() 
     806        bestRules = Orange.core.RuleList() 
    807807##        for r in currentRules: 
    808 ##            if hasattr(r.learner, "argumentRule") and not orngCN2.rule_in_set(r,bestRules): 
     808##            if hasattr(r.learner, "argumentRule") and not Orange.classification.rules.rule_in_set(r,bestRules): 
    809809##                bestRules.append(r) 
    810810        for r_i,r in enumerate(self.bestRule): 
    811             if r and not orngCN2.rule_in_set(r,bestRules) and int(examples[r_i].getclass())==int(r.classifier.defaultValue): 
     811            if r and not Orange.classification.rules.rule_in_set(r,bestRules) and int(examples[r_i].getclass())==int(r.classifier.defaultValue): 
    812812                bestRules.append(r) 
    813813        return bestRules 
     
    868868         
    869869    def createRandomDataSet(self, data): 
    870         newData = orange.ExampleTable(data) 
     870        newData = Orange.core.ExampleTable(data) 
    871871        # shuffle data 
    872872        cl_num = newData.toNumpy("C") 
    873873        random.shuffle(cl_num[0][:,0]) 
    874         clData = orange.ExampleTable(orange.Domain([newData.domain.classVar]),cl_num[0]) 
     874        clData = Orange.core.ExampleTable(Orange.core.Domain([newData.domain.classVar]),cl_num[0]) 
    875875        for d_i,d in enumerate(newData): 
    876876            d[newData.domain.classVar] = clData[d_i][newData.domain.classVar] 
     
    878878 
    879879    def createEVDistList(self, evdList): 
    880         l = orange.EVDistList() 
     880        l = Orange.core.EVDistList() 
    881881        for el in evdList: 
    882             l.append(orange.EVDist(mu=el[0],beta=el[1],percentiles=el[2])) 
     882            l.append(Orange.core.EVDist(mu=el[0],beta=el[1],percentiles=el[2])) 
    883883        return l 
    884884 
     
    902902        self.ruleFilter = self.learner.ruleFinder.ruleFilter 
    903903        self.learner.ruleFinder.validator = None 
    904         self.learner.ruleFinder.evaluator = orange.RuleEvaluator_LRS() 
     904        self.learner.ruleFinder.evaluator = Orange.core.RuleEvaluator_LRS() 
    905905        self.learner.ruleFinder.evaluator.storeRules = True 
    906         self.learner.ruleFinder.ruleStoppingValidator = orange.RuleValidator_LRS(alpha=1.0) 
     906        self.learner.ruleFinder.ruleStoppingValidator = Orange.core.RuleValidator_LRS(alpha=1.0) 
    907907        self.learner.ruleFinder.ruleStoppingValidator.max_rule_complexity = 0 
    908         self.learner.ruleFinder.refiner = orange.RuleBeamRefiner_Selector() 
    909         self.learner.ruleFinder.ruleFilter = orange.RuleBeamFilter_Width(width = 1) 
     908        self.learner.ruleFinder.refiner = Orange.core.RuleBeamRefiner_Selector() 
     909        self.learner.ruleFinder.ruleFilter = Orange.core.RuleBeamFilter_Width(width = 1) 
    910910 
    911911 
     
    935935            # create data set (remove and randomize) 
    936936            tempData = self.createRandomDataSet(data) 
    937             self.learner.ruleFinder.evaluator.rules = orange.RuleList() 
     937            self.learner.ruleFinder.evaluator.rules = Orange.core.RuleList() 
    938938            # Next, learn a rule 
    939             self.learner.ruleFinder(tempData,weightID,target_class, orange.RuleList()) 
     939            self.learner.ruleFinder(tempData,weightID,target_class, Orange.core.RuleList()) 
    940940            for l in range(self.oldStopper.max_rule_complexity): 
    941941                qs = [r.quality for r in self.learner.ruleFinder.evaluator.rules if r.complexity == l+1] 
     
    968968 
    969969    def get_prob_from_res(self, res, examples): 
    970         probDist = orange.DistributionList() 
     970        probDist = Orange.core.DistributionList() 
    971971        for tex in res.results: 
    972             d = orange.Distribution(examples.domain.classVar) 
     972            d = Orange.core.Distribution(examples.domain.classVar) 
    973973            for di in range(len(d)): 
    974974                d[di] = tex.probabilities[0][di] 
     
    991991            probDist = self.selected_evaluation(self.alternative_learner, examples, weight) 
    992992            classifier = self.alternative_learner(examples,weight) 
    993 ##            probDist = orange.DistributionList() 
     993##            probDist = Orange.core.DistributionList() 
    994994##            for e in examples: 
    995 ##                probDist.append(classifier(e,orange.GetProbabilities)) 
    996             cl = orange.RuleClassifier_logit(rules, self.min_cl_sig, self.min_beta, examples, weight, self.set_prefix_rules, self.optimize_betas, classifier, probDist) 
     995##                probDist.append(classifier(e,Orange.core.GetProbabilities)) 
     996            cl = Orange.core.RuleClassifier_logit(rules, self.min_cl_sig, self.min_beta, examples, weight, self.set_prefix_rules, self.optimize_betas, classifier, probDist) 
    997997        else: 
    998             cl = orange.RuleClassifier_logit(rules, self.min_cl_sig, self.min_beta, examples, weight, self.set_prefix_rules, self.optimize_betas) 
     998            cl = Orange.core.RuleClassifier_logit(rules, self.min_cl_sig, self.min_beta, examples, weight, self.set_prefix_rules, self.optimize_betas) 
    999999 
    10001000##        print "result" 
     
    10021002            cl.rules[ri].setattr("beta",cl.ruleBetas[ri]) 
    10031003##            if cl.ruleBetas[ri] > 0: 
    1004 ##                print orngCN2.ruleToString(r), r.quality, cl.ruleBetas[ri] 
     1004##                print Orange.classification.rules.ruleToString(r), r.quality, cl.ruleBetas[ri] 
    10051005        cl.all_rules = cl.rules 
    10061006        cl.rules = self.sortRules(cl.rules) 
     
    10111011    def add_null_rule(self, rules, examples, weight): 
    10121012        for cl in examples.domain.classVar: 
    1013             tmpRle = orange.Rule() 
    1014             tmpRle.filter = orange.Filter_values(domain = examples.domain) 
     1013            tmpRle = Orange.core.Rule() 
     1014            tmpRle.filter = Orange.core.Filter_values(domain = examples.domain) 
    10151015            tmpRle.parentRule = None 
    10161016            tmpRle.filterAndStore(examples,weight,int(cl)) 
     
    10201020         
    10211021    def sortRules(self, rules): 
    1022         newRules = orange.RuleList() 
     1022        newRules = Orange.core.RuleList() 
    10231023        foundRule = True 
    10241024        while foundRule: 
     
    10471047 
    10481048 
    1049 class CN2UnorderedClassifier(orange.RuleClassifier): 
     1049class CN2UnorderedClassifier(Orange.core.RuleClassifier): 
    10501050    """ Classification from rules as in CN2. """ 
    10511051    def __init__(self, rules, examples, weightID = 0, **argkw): 
     
    10531053        self.examples = examples 
    10541054        self.weightID = weightID 
    1055         self.prior = orange.Distribution(examples.domain.classVar, examples, weightID) 
     1055        self.prior = Orange.core.Distribution(examples.domain.classVar, examples, weightID) 
    10561056        self.__dict__.update(argkw) 
    10571057 
    1058     def __call__(self, example, result_type=orange.GetValue, retRules = False): 
     1058    def __call__(self, example, result_type=Orange.core.GetValue, retRules = False): 
    10591059        # iterate through the set of induced rules: self.rules and sum their distributions  
    10601060        ret_dist = self.sum_distributions([r for r in self.rules if r(example)]) 
     
    10651065##        ret_dist.normalize() 
    10661066        # return value 
    1067         if result_type == orange.GetValue: 
     1067        if result_type == Orange.core.GetValue: 
    10681068          return ret_dist.modus() 
    1069         if result_type == orange.GetProbabilities: 
     1069        if result_type == Orange.core.GetProbabilities: 
    10701070          return ret_dist 
    10711071        return (ret_dist.modus(),ret_dist) 
     
    10741074        if not rules: 
    10751075            return self.prior 
    1076         empty_disc = orange.Distribution(rules[0].examples.domain.classVar) 
     1076        empty_disc = Orange.core.Distribution(rules[0].examples.domain.classVar) 
    10771077        for r in rules: 
    10781078            for i,d in enumerate(r.classDistribution): 
     
    10831083        retStr = "" 
    10841084        for r in self.rules: 
    1085             retStr += orngCN2.ruleToString(r)+" "+str(r.classDistribution)+"\n" 
     1085            retStr += Orange.classification.rules.ruleToString(r)+" "+str(r.classDistribution)+"\n" 
    10861086        return retStr 
    10871087 
    10881088 
    1089 class RuleClassifier_bestRule(orange.RuleClassifier): 
     1089class RuleClassifier_bestRule(Orange.core.RuleClassifier): 
    10901090    """ A very simple classifier, it takes the best rule of each class and normalizes probabilities. """ 
    10911091    def __init__(self, rules, examples, weightID = 0, **argkw): 
    10921092        self.rules = rules 
    10931093        self.examples = examples 
    1094         self.apriori = orange.Distribution(examples.domain.classVar,examples,weightID) 
     1094        self.apriori = Orange.core.Distribution(examples.domain.classVar,examples,weightID) 
    10951095        self.aprioriProb = [a/self.apriori.abs for a in self.apriori] 
    10961096        self.weightID = weightID 
     
    10981098        self.defaultClassIndex = -1 
    10991099 
    1100     def __call__(self, example, result_type=orange.GetValue, retRules = False): 
    1101         example = orange.Example(self.examples.domain,example) 
    1102         tempDist = orange.Distribution(example.domain.classVar) 
     1100    def __call__(self, example, result_type=Orange.core.GetValue, retRules = False): 
     1101        example = Orange.core.Example(self.examples.domain,example) 
     1102        tempDist = Orange.core.Distribution(example.domain.classVar) 
    11031103        bestRules = [None]*len(example.domain.classVar.values) 
    11041104 
     
    11181118                if tempDist[a_i] == 0.: 
    11191119                    tempDist[a_i]=self.aprioriProb[a_i]*residue/nonCovPriorSum 
    1120             finalDist = tempDist #orange.Distribution(example.domain.classVar) 
     1120            finalDist = tempDist #Orange.core.Distribution(example.domain.classVar) 
    11211121        else: 
    11221122            tempDist.normalize() # prior probability 
    1123             tmpExamples = orange.ExampleTable(self.examples) 
     1123            tmpExamples = Orange.core.ExampleTable(self.examples) 
    11241124            for r in bestRules: 
    11251125                if r: 
    11261126                    tmpExamples = r.filter(tmpExamples) 
    1127             tmpDist = orange.Distribution(tmpExamples.domain.classVar,tmpExamples,self.weightID) 
     1127            tmpDist = Orange.core.Distribution(tmpExamples.domain.classVar,tmpExamples,self.weightID) 
    11281128            tmpDist.normalize() 
    11291129            probs = [0.]*len(self.examples.domain.classVar.values) 
    11301130            for i in range(len(self.examples.domain.classVar.values)): 
    11311131                probs[i] = tmpDist[i]+tempDist[i]*2 
    1132             finalDist = orange.Distribution(self.examples.domain.classVar) 
     1132            finalDist = Orange.core.Distribution(self.examples.domain.classVar) 
    11331133            for cl_i,cl in enumerate(self.examples.domain.classVar): 
    11341134                finalDist[cl] = probs[cl_i] 
     
    11361136                 
    11371137        if retRules: # Do you want to return rules with classification? 
    1138             if result_type == orange.GetValue: 
     1138            if result_type == Orange.core.GetValue: 
    11391139              return (finalDist.modus(),bestRules) 
    1140             if result_type == orange.GetProbabilities: 
     1140            if result_type == Orange.core.GetProbabilities: 
    11411141              return (finalDist, bestRules) 
    11421142            return (finalDist.modus(),finalDist, bestRules) 
    1143         if result_type == orange.GetValue: 
     1143        if result_type == Orange.core.GetValue: 
    11441144          return finalDist.modus() 
    1145         if result_type == orange.GetProbabilities: 
     1145        if result_type == Orange.core.GetProbabilities: 
    11461146          return finalDist 
    11471147        return (finalDist.modus(),finalDist) 
  • orange/orngABML.py

    r6652 r7223  
    11# This module is used to handle argumented examples. 
    22 
    3 import orange 
     3import Orange.core 
    44import re 
    55import string 
    66import warnings 
    77 
    8 import orngCN2 
     8import Orange.classification.rules 
    99import numpy 
    1010 
     
    2727 
    2828def strSign(oper): 
    29     if oper == orange.ValueFilter_continuous.Less: 
     29    if oper == Orange.core.ValueFilter_continuous.Less: 
    3030        return "<" 
    31     elif oper == orange.ValueFilter_continuous.LessEqual: 
     31    elif oper == Orange.core.ValueFilter_continuous.LessEqual: 
    3232        return "<=" 
    33     elif oper == orange.ValueFilter_continuous.Greater: 
     33    elif oper == Orange.core.ValueFilter_continuous.Greater: 
    3434        return ">" 
    35     elif oper == orange.ValueFilter_continuous.GreaterEqual: 
     35    elif oper == Orange.core.ValueFilter_continuous.GreaterEqual: 
    3636        return ">=" 
    3737    else: return "=" 
    3838 
    3939def strArg(arg, domain, leave_ref): 
    40     if type(arg) == orange.ValueFilter_discrete: 
     40    if type(arg) == Orange.core.ValueFilter_discrete: 
    4141        return str(domain[arg.position].name) 
    4242    else: 
     
    6262    this class is used as a value for ArgumentationVariable. """ 
    6363    def __init__(self): 
    64         self.positiveArguments = orange.RuleList() 
    65         self.negativeArguments = orange.RuleList() 
     64        self.positiveArguments = Orange.core.RuleList() 
     65        self.negativeArguments = Orange.core.RuleList() 
    6666        self.notYetComputedArguments = [] # Arguments that need the whole data set 
    6767                                          # when processing are stored here  
     
    101101POSITIVE = True 
    102102NEGATIVE = False 
    103 class ArgumentVariable(orange.PythonVariable): 
     103class ArgumentVariable(Orange.core.PythonVariable): 
    104104    """ For writing and parsing arguments in .tab files. """ 
    105105    def str2val(self, strV): 
     
    112112        if not mt or not mt.end() == len(strV): 
    113113            warnings.warn(strV+" is a badly formed argument.") 
    114             return orange.PythonValueSpecial(2) # return special if argument doesnt match the formal form  
     114            return Orange.core.PythonValueSpecial(2) # return special if argument doesnt match the formal form  
    115115 
    116116        if not example: 
     
    129129                type = NEGATIVE 
    130130                continue 
    131             argument = orange.Rule(filter=orange.Filter_values(domain=domain)) 
     131            argument = Orange.core.Rule(filter=Orange.core.Filter_values(domain=domain)) 
    132132            argument.setattr("unspecialized_argument",False) 
    133133             
     
    145145                        continue 
    146146                    value = example[attribute] 
    147                     if attribute.varType == orange.VarTypes.Discrete: # discrete argument 
    148                         argument.filter.conditions.append(orange.ValueFilter_discrete( 
     147                    if attribute.varType == Orange.core.VarTypes.Discrete: # discrete argument 
     148                        argument.filter.conditions.append(Orange.core.ValueFilter_discrete( 
    149149                                                            position = domain.attributes.index(attribute), 
    150150                                                            values=[value], 
     
    188188                    else: 
    189189                        ref = 0.                         
    190                     if sign == "<": oper = orange.ValueFilter_continuous.Less 
    191                     elif sign == ">": oper = orange.ValueFilter_continuous.Greater 
    192                     elif sign == "<=": oper = orange.ValueFilter_continuous.LessEqual 
    193                     else: oper = orange.ValueFilter_continuous.GreaterEqual 
    194                     argument.filter.conditions.append(orange.ValueFilter_continuous( 
     190                    if sign == "<": oper = Orange.core.ValueFilter_continuous.Less 
     191                    elif sign == ">": oper = Orange.core.ValueFilter_continuous.Greater 
     192                    elif sign == "<=": oper = Orange.core.ValueFilter_continuous.LessEqual 
     193                    else: oper = Orange.core.ValueFilter_continuous.GreaterEqual 
     194                    argument.filter.conditions.append(Orange.core.ValueFilter_continuous( 
    195195                                                position = domain.attributes.index(attribute), 
    196196                                                oper=oper, 
     
    204204 
    205205            if example.domain.classVar: 
    206                 argument.classifier = orange.DefaultClassifier(defaultVal = example.getclass()) 
     206                argument.classifier = Orange.core.DefaultClassifier(defaultVal = example.getclass()) 
    207207            argument.complexity = len(argument.filter.conditions) 
    208208 
     
    239239    """ Evaluate positive arguments and sort them by quality. """ 
    240240    if not apriori: 
    241         apriori = orange.Distribution(examples.domain.classVar,examples) 
     241        apriori = Orange.core.Distribution(examples.domain.classVar,examples) 
    242242    if not evaluateFunction: 
    243         evaluateFunction = orange.RuleEvaluator_Laplace() 
     243        evaluateFunction = Orange.core.RuleEvaluator_Laplace() 
    244244         
    245245    for e in examples: 
     
    251251 
    252252def isGreater(oper): 
    253     if oper == orange.ValueFilter_continuous.Greater or \ 
    254        oper == orange.ValueFilter_continuous.GreaterEqual: 
     253    if oper == Orange.core.ValueFilter_continuous.Greater or \ 
     254       oper == Orange.core.ValueFilter_continuous.GreaterEqual: 
    255255        return True 
    256256    return False 
    257257 
    258258def isLess(oper): 
    259     if oper == orange.ValueFilter_continuous.Less or \ 
    260        oper == orange.ValueFilter_continuous.LessEqual: 
     259    if oper == Orange.core.ValueFilter_continuous.Less or \ 
     260       oper == Orange.core.ValueFilter_continuous.LessEqual: 
    261261        return True 
    262262    return False 
     
    271271    def __call__(self,example, returnWhat): 
    272272        if example[self.classAtt] == self.classValue: 
    273             return orange.Value(self.newClassAtt, self.classValue+"_") 
     273            return Orange.core.Value(self.newClassAtt, self.classValue+"_") 
    274274        else: 
    275             return orange.Value(self.newClassAtt, "not " + self.classValue) 
     275            return Orange.core.Value(self.newClassAtt, "not " + self.classValue) 
    276276     
    277277def createDichotomousClass(domain, att, value, negate, removeAtt = None): 
    278278    # create new variable 
    279     newClass = orange.EnumVariable(att.name+"_", values = [str(value)+"_", "not " + str(value)]) 
    280     positive = orange.Value(newClass, str(value)+"_") 
    281     negative = orange.Value(newClass, "not " + str(value)) 
     279    newClass = Orange.core.EnumVariable(att.name+"_", values = [str(value)+"_", "not " + str(value)]) 
     280    positive = Orange.core.Value(newClass, str(value)+"_") 
     281    negative = Orange.core.Value(newClass, "not " + str(value)) 
    282282    newClass.getValueFrom = ConvertClass(att,str(value),newClass) 
    283283     
    284284    att = [a for a in domain.attributes] 
    285     newDomain = orange.Domain(att+[newClass]) 
     285    newDomain = Orange.core.Domain(att+[newClass]) 
    286286    newDomain.addmetas(domain.getmetas()) 
    287287    if negate==1: 
     
    303303        if isLess(self.oper): 
    304304            if example[self.position]<self.value: 
    305                 return orange.Value(self.newAtt, self.value) 
     305                return Orange.core.Value(self.newAtt, self.value) 
    306306            else: 
    307                 return orange.Value(self.newAtt, float(example[self.position])) 
     307                return Orange.core.Value(self.newAtt, float(example[self.position])) 
    308308        else: 
    309309            if example[self.position]>self.value: 
    310                 return orange.Value(self.newAtt, self.value) 
     310                return Orange.core.Value(self.newAtt, self.value) 
    311311            else: 
    312                 return orange.Value(self.newAtt, float(example[self.position])) 
     312                return Orange.core.Value(self.newAtt, float(example[self.position])) 
  • orange/orngCN2.py

    r7104 r7223  
    1 import orange 
    2 import random, math 
    3 from orngABCN2 import ABCN2 
    4  
    5 def ruleToString(rule, showDistribution = True): 
    6     def selectSign(oper): 
    7         if oper == orange.ValueFilter_continuous.Less: 
    8             return "<" 
    9         elif oper == orange.ValueFilter_continuous.LessEqual: 
    10             return "<=" 
    11         elif oper == orange.ValueFilter_continuous.Greater: 
    12             return ">" 
    13         elif oper == orange.ValueFilter_continuous.GreaterEqual: 
    14             return ">=" 
    15         else: return "=" 
    16  
    17     if not rule: 
    18         return "None" 
    19     conds = rule.filter.conditions 
    20     domain = rule.filter.domain 
    21      
    22     ret = "IF " 
    23     if len(conds)==0: 
    24         ret = ret + "TRUE" 
    25  
    26     for i,c in enumerate(conds): 
    27         if i > 0: 
    28             ret += " AND " 
    29         if type(c) == orange.ValueFilter_discrete: 
    30             ret += domain[c.position].name + "=" + str([domain[c.position].values[int(v)] for v in c.values]) 
    31         elif type(c) == orange.ValueFilter_continuous: 
    32             ret += domain[c.position].name + selectSign(c.oper) + str(c.ref) 
    33     if rule.classifier and type(rule.classifier) == orange.DefaultClassifier and rule.classifier.defaultVal: 
    34         ret = ret + " THEN "+domain.classVar.name+"="+\ 
    35         str(rule.classifier.defaultValue) 
    36         if showDistribution: 
    37             ret += str(rule.classDistribution) 
    38     elif rule.classifier and type(rule.classifier) == orange.DefaultClassifier and type(domain.classVar) == orange.EnumVariable: 
    39         ret = ret + " THEN "+domain.classVar.name+"="+\ 
    40         str(rule.classDistribution.modus()) 
    41         if showDistribution: 
    42             ret += str(rule.classDistribution) 
    43     return ret         
    44  
    45 class LaplaceEvaluator(orange.RuleEvaluator): 
    46     def __call__(self, rule, data, weightID, targetClass, apriori): 
    47         if not rule.classDistribution: 
    48             return 0. 
    49         sumDist = rule.classDistribution.cases 
    50         if not sumDist or (targetClass>-1 and not rule.classDistribution[targetClass]): 
    51             return 0. 
    52         # get distribution 
    53         if targetClass>-1: 
    54             return (rule.classDistribution[targetClass]+1)/(sumDist+2) 
    55         else: 
    56             return (max(rule.classDistribution)+1)/(sumDist+len(data.domain.classVar.values)) 
    57  
    58 class WRACCEvaluator(orange.RuleEvaluator): 
    59     def __call__(self, rule, data, weightID, targetClass, apriori): 
    60         if not rule.classDistribution: 
    61             return 0. 
    62         sumDist = rule.classDistribution.cases 
    63         if not sumDist or (targetClass>-1 and not rule.classDistribution[targetClass]): 
    64             return 0. 
    65         # get distribution 
    66         if targetClass>-1: 
    67             pRule = rule.classDistribution[targetClass]/apriori[targetClass] 
    68             pTruePositive = rule.classDistribution[targetClass]/sumDist 
    69             pClass = apriori[targetClass]/apriori.cases 
    70         else: 
    71             pRule = sumDist/apriori.cases 
    72             pTruePositive = max(rule.classDistribution)/sumDist 
    73             pClass = apriori[rule.classDistribution.modus()]/sum(apriori) 
    74         if pTruePositive>pClass: 
    75             return pRule*(pTruePositive-pClass) 
    76         else: return (pTruePositive-pClass)/max(pRule,1e-6) 
    77  
    78 class mEstimate(orange.RuleEvaluator): 
    79     def __init__(self, m=2): 
    80         self.m = m 
    81     def __call__(self, rule, data, weightID, targetClass, apriori): 
    82         if not rule.classDistribution: 
    83             return 0. 
    84         sumDist = rule.classDistribution.abs 
    85         if self.m == 0 and not sumDist: 
    86             return 0. 
    87         # get distribution 
    88         if targetClass>-1: 
    89             p = rule.classDistribution[targetClass]+self.m*apriori[targetClass]/apriori.abs 
    90             p = p / (rule.classDistribution.abs + self.m) 
    91         else: 
    92             p = max(rule.classDistribution)+self.m*apriori[rule.classDistribution.modus()]/apriori.abs 
    93             p = p / (rule.classDistribution.abs + self.m)       
    94         return p 
    95  
    96 class RuleStopping_apriori(orange.RuleStoppingCriteria): 
    97     def __init__(self, apriori=None): 
    98         self.apriori =  None 
    99          
    100     def __call__(self,rules,rule,examples,data): 
    101         if not self.apriori: 
    102             return False 
    103         if not type(rule.classifier) == orange.DefaultClassifier: 
    104             return False 
    105         ruleAcc = rule.classDistribution[rule.classifier.defaultVal]/rule.classDistribution.abs 
    106         aprioriAcc = self.apriori[rule.classifier.defaultVal]/self.apriori.abs 
    107         if ruleAcc>aprioriAcc: 
    108             return False 
    109         return True 
    110  
    111 class LengthValidator(orange.RuleValidator): 
    112     """ prune rules with more conditions than self.length. """ 
    113     def __init__(self, length=-1): 
    114         self.length = length 
    115          
    116     def __call__(self, rule, data, weightID, targetClass, apriori): 
    117         if self.length >= 0: 
    118             return len(rule.filter.conditions) <= self.length 
    119         return True     
    120      
    121  
    122 def supervisedClassCheck(examples): 
    123     if not examples.domain.classVar: 
    124         raise Exception("Class variable is required!") 
    125     if examples.domain.classVar.varType == orange.VarTypes.Continuous: 
    126         raise Exception("CN2 requires a discrete class!") 
    127      
    128 class CN2Learner(orange.RuleLearner): 
    129     def __new__(cls, examples=None, weightID=0, **kwargs): 
    130         self = orange.RuleLearner.__new__(cls, **kwargs) 
    131         if examples is not None: 
    132             self.__init__(**kwargs) 
    133             return self.__call__(examples, weightID) 
    134         else: 
    135             return self 
    136          
    137     def __init__(self, evaluator = orange.RuleEvaluator_Entropy(), beamWidth = 5, alpha = 1.0, **kwds): 
    138         self.__dict__.update(kwds) 
    139         self.ruleFinder = orange.RuleBeamFinder() 
    140         self.ruleFinder.ruleFilter = orange.RuleBeamFilter_Width(width = beamWidth) 
    141         self.ruleFinder.evaluator = evaluator 
    142         self.ruleFinder.validator = orange.RuleValidator_LRS(alpha = alpha) 
    143          
    144     def __call__(self, examples, weight=0): 
    145         supervisedClassCheck(examples) 
    146          
    147         cl = orange.RuleLearner.__call__(self,examples,weight) 
    148         rules = cl.rules 
    149         return CN2Classifier(rules, examples, weight) 
    150  
    151 class CN2Classifier(orange.RuleClassifier): 
    152     def __init__(self, rules=None, examples=None, weightID = 0, **argkw): 
    153         self.rules = rules 
    154         self.examples = examples 
    155         self.weightID = weightID 
    156         self.classVar = None if examples is None else examples.domain.classVar 
    157         self.__dict__.update(argkw) 
    158         if examples is not None: 
    159             self.prior = orange.Distribution(examples.domain.classVar, examples) 
    160  
    161     def __call__(self, example, result_type=orange.GetValue): 
    162         classifier = None 
    163         for r in self.rules: 
    164          #   r.filter.domain = example.domain 
    165             if r(example) and r.classifier: 
    166                 classifier = r.classifier 
    167                 classifier.defaultDistribution = r.classDistribution 
    168                 break 
    169         if not classifier: 
    170             classifier = orange.DefaultClassifier(example.domain.classVar, self.prior.modus()) 
    171             classifier.defaultDistribution = self.prior 
    172  
    173         if result_type == orange.GetValue: 
    174           return classifier(example) 
    175         if result_type == orange.GetProbabilities: 
    176           return classifier.defaultDistribution 
    177         return (classifier(example),classifier.defaultDistribution) 
    178  
    179     def __str__(self): 
    180         retStr = ruleToString(self.rules[0])+" "+str(self.rules[0].classDistribution)+"\n" 
    181         for r in self.rules[1:]: 
    182             retStr += "ELSE "+ruleToString(r)+" "+str(r.classDistribution)+"\n" 
    183         return retStr 
    184  
    185  
    186 # Kako nastavim v c++, da mi ni potrebno dodati imena 
    187 class CN2UnorderedLearner(orange.RuleLearner): 
    188     def __new__(cls, examples=None, weightID=0, **kwargs): 
    189         self = orange.RuleLearner.__new__(cls, **kwargs) 
    190         if examples is not None: 
    191             self.__init__(**kwargs) 
    192             return self.__call__(examples, weightID) 
    193         else: 
    194             return self 
    195              
    196     def __init__(self, evaluator = orange.RuleEvaluator_Laplace(), beamWidth = 5, alpha = 1.0, **kwds): 
    197         self.__dict__.update(kwds) 
    198         self.ruleFinder = orange.RuleBeamFinder() 
    199         self.ruleFinder.ruleFilter = orange.RuleBeamFilter_Width(width = beamWidth) 
    200         self.ruleFinder.evaluator = evaluator 
    201         self.ruleFinder.validator = orange.RuleValidator_LRS(alpha = alpha) 
    202         self.ruleFinder.ruleStoppingValidator = orange.RuleValidator_LRS(alpha = 1.0) 
    203         self.ruleStopping = RuleStopping_apriori() 
    204         self.dataStopping = orange.RuleDataStoppingCriteria_NoPositives() 
    205          
    206     def __call__(self, examples, weight=0): 
    207         supervisedClassCheck(examples) 
    208          
    209         rules = orange.RuleList() 
    210         self.ruleStopping.apriori = orange.Distribution(examples.domain.classVar,examples) 
    211         progress=getattr(self,"progressCallback",None) 
    212         if progress: 
    213             progress.start = 0.0 
    214             progress.end = 0.0 
    215             distrib = orange.Distribution(examples.domain.classVar, examples, weight) 
    216             distrib.normalize() 
    217         for targetClass in examples.domain.classVar: 
    218             if progress: 
    219                 progress.start = progress.end 
    220                 progress.end += distrib[targetClass] 
    221             self.targetClass = targetClass 
    222             cl = orange.RuleLearner.__call__(self,examples,weight) 
    223             for r in cl.rules: 
    224                 rules.append(r) 
    225         if progress: 
    226             progress(1.0,None) 
    227         return CN2UnorderedClassifier(rules, examples, weight) 
    228  
    229  
    230 class CN2UnorderedClassifier(orange.RuleClassifier): 
    231     def __init__(self, rules = None, examples = None, weightID = 0, **argkw): 
    232         self.rules = rules 
    233         self.examples = examples 
    234         self.weightID = weightID 
    235         self.classVar = examples.domain.classVar if examples is not None else None 
    236         self.__dict__.update(argkw) 
    237         if examples is not None: 
    238             self.prior = orange.Distribution(examples.domain.classVar, examples) 
    239  
    240     def __call__(self, example, result_type=orange.GetValue, retRules = False): 
    241         def add(disc1, disc2, sumd): 
    242             disc = orange.DiscDistribution(disc1) 
    243             sumdisc = sumd 
    244             for i,d in enumerate(disc): 
    245                 disc[i]+=disc2[i] 
    246                 sumdisc += disc2[i] 
    247             return disc, sumdisc 
    248  
    249         # create empty distribution 
    250         retDist = orange.DiscDistribution(self.examples.domain.classVar) 
    251         covRules = orange.RuleList() 
    252         # iterate through examples - add distributions 
    253         sumdisc = 0. 
    254         for r in self.rules: 
    255             if r(example) and r.classDistribution: 
    256                 retDist, sumdisc = add(retDist, r.classDistribution, sumdisc) 
    257                 covRules.append(r) 
    258         if not sumdisc: 
    259             retDist = self.prior 
    260             sumdisc = self.prior.abs 
    261              
    262         if sumdisc > 0.0: 
    263             for c in self.examples.domain.classVar: 
    264                 retDist[c] /= sumdisc 
    265         else: 
    266             retDist.normalize() 
    267          
    268         if retRules: 
    269             if result_type == orange.GetValue: 
    270               return (retDist.modus(), covRules) 
    271             if result_type == orange.GetProbabilities: 
    272               return (retDist, covRules) 
    273             return (retDist.modus(),retDist,covRules) 
    274         if result_type == orange.GetValue: 
    275           return retDist.modus() 
    276         if result_type == orange.GetProbabilities: 
    277           return retDist 
    278         return (retDist.modus(),retDist) 
    279  
    280     def __str__(self): 
    281         retStr = "" 
    282         for r in self.rules: 
    283             retStr += ruleToString(r)+" "+str(r.classDistribution)+"\n" 
    284         return retStr 
    285  
    286 class RuleClassifier_bestRule(orange.RuleClassifier): 
    287     def __init__(self, rules, examples, weightID = 0, **argkw): 
    288         self.rules = rules 
    289         self.examples = examples 
    290         self.classVar = examples.domain.classVar 
    291         self.__dict__.update(argkw) 
    292         self.prior = orange.Distribution(examples.domain.classVar, examples) 
    293  
    294     def __call__(self, example, result_type=orange.GetValue): 
    295         retDist = orange.Distribution(example.domain.classVar) 
    296         bestRule = None 
    297         for r in self.rules: 
    298             if r(example) and (not bestRule or r.quality>bestRule.quality): 
    299                 for v_i,v in enumerate(example.domain.classVar): 
    300                     retDist[v_i] = r.classDistribution[v_i] 
    301                 bestRule = r 
    302         if not bestRule: 
    303             retDist = self.prior 
    304         else: 
    305             bestRule.used += 1 
    306         sumdist = sum(retDist) 
    307         if sumdist > 0.0: 
    308             for c in self.examples.domain.classVar: 
    309                 retDist[c] /= sumdisc 
    310         else: 
    311             retDist.normalize() 
    312         # return classifier(example, result_type=result_type) 
    313         if result_type == orange.GetValue: 
    314           return retDist.modus() 
    315         if result_type == orange.GetProbabilities: 
    316           return retDist 
    317         return (retDist.modus(),retDist) 
    318  
    319     def __str__(self): 
    320         retStr = "" 
    321         for r in self.rules: 
    322             retStr += ruleToString(r)+" "+str(r.classDistribution)+"\n" 
    323         return retStr     
    324  
    325 class CovererAndRemover_multWeights(orange.RuleCovererAndRemover): 
    326     def __init__(self, mult = 0.7): 
    327         self.mult = mult 
    328     def __call__(self, rule, examples, weights, targetClass): 
    329         if not weights: 
    330             weights = orange.newmetaid() 
    331             examples.addMetaAttribute(weights,1.) 
    332             examples.domain.addmeta(weights, orange.FloatVariable("weights-"+str(weights)), True) 
    333         newWeightsID = orange.newmetaid() 
    334         examples.addMetaAttribute(newWeightsID,1.) 
    335         examples.domain.addmeta(newWeightsID, orange.FloatVariable("weights-"+str(newWeightsID)), True) 
    336         for example in examples: 
    337             if rule(example) and example.getclass() == rule.classifier(example,orange.GetValue): 
    338                 example[newWeightsID]=example[weights]*self.mult 
    339             else: 
    340                 example[newWeightsID]=example[weights] 
    341         return (examples,newWeightsID) 
    342  
    343 class CovererAndRemover_addWeights(orange.RuleCovererAndRemover): 
    344     def __call__(self, rule, examples, weights, targetClass): 
    345         if not weights: 
    346             weights = orange.newmetaid() 
    347             examples.addMetaAttribute(weights,1.) 
    348             examples.domain.addmeta(weights, orange.FloatVariable("weights-"+str(weights)), True) 
    349         try: 
    350             coverage = examples.domain.getmeta("Coverage") 
    351         except: 
    352             coverage = orange.FloatVariable("Coverage") 
    353             examples.domain.addmeta(orange.newmetaid(),coverage, True) 
    354             examples.addMetaAttribute(coverage,0.0) 
    355         newWeightsID = orange.newmetaid() 
    356         examples.addMetaAttribute(newWeightsID,1.) 
    357         examples.domain.addmeta(newWeightsID, orange.FloatVariable("weights-"+str(newWeightsID)), True) 
    358         for example in examples: 
    359             if rule(example) and example.getclass() == rule.classifier(example,orange.GetValue): 
    360                 try: 
    361                     example[coverage]+=1.0 
    362                 except: 
    363                     example[coverage]=1.0 
    364                 example[newWeightsID]=1.0/(example[coverage]+1) 
    365             else: 
    366                 example[newWeightsID]=example[weights] 
    367         return (examples,newWeightsID) 
    368  
    369 def rule_in_set(rule,rules): 
    370     for r in rules: 
    371         if rules_equal(rule,r): 
    372             return True 
    373     return False 
    374  
    375 def rules_equal(rule1,rule2): 
    376     if not len(rule1.filter.conditions)==len(rule2.filter.conditions): 
    377         return False 
    378     for c1 in rule1.filter.conditions: 
    379         found=False # find the same condition in the other rule 
    380         for c2 in rule2.filter.conditions: 
    381             try: 
    382                 if not c1.position == c2.position: continue # same attribute? 
    383                 if not type(c1) == type(c2): continue # same type of condition 
    384                 if type(c1) == orange.ValueFilter_discrete: 
    385                     if not type(c1.values[0]) == type(c2.values[0]): continue 
    386                     if not c1.values[0] == c2.values[0]: continue # same value? 
    387                 if type(c1) == orange.ValueFilter_continuous: 
    388                     if not c1.oper == c2.oper: continue # same operator? 
    389                     if not c1.ref == c2.ref: continue #same threshold? 
    390                 found=True 
    391                 break 
    392             except: 
    393                 pass 
    394         if not found: 
    395             return False 
    396     return True 
    397  
    398 class noDuplicates_validator(orange.RuleValidator): 
    399     def __init__(self,alpha=.05,min_coverage=0,max_rule_length=0,rules=orange.RuleList()): 
    400         self.rules = rules 
    401         self.validator = orange.RuleValidator_LRS(alpha=alpha,min_coverage=min_coverage,max_rule_length=max_rule_length) 
    402          
    403     def __call__(self, rule, data, weightID, targetClass, apriori): 
    404         if rule_in_set(rule,self.rules): 
    405             return False 
    406         return bool(self.validator(rule,data,weightID,targetClass,apriori)) 
    407                  
    408 class ruleSt_setRules(orange.RuleStoppingCriteria): 
    409     def __init__(self,validator): 
    410         self.ruleStopping = orange.RuleStoppingCriteria_NegativeDistribution() 
    411         self.validator = validator 
    412  
    413     def __call__(self,rules,rule,examples,data):         
    414         ru_st = self.ruleStopping(rules,rule,examples,data) 
    415         if not ru_st: 
    416             self.validator.rules.append(rule) 
    417         return bool(ru_st) 
    418 # 
    419 #def CN2SDUnorderedLearner(examples = None, weightID=0, **kwds): 
    420 #    cn2 = CN2SDUnorderedLearnerClass(**kwds) 
    421 #    if examples: 
    422 #        return cn2(examples, weightID) 
    423 #    else: 
    424 #        return cn2 
    425      
    426 class CN2SDUnorderedLearner(CN2UnorderedLearner): 
    427     def __new__(cls, examples=None, weightID=0, **kwargs): 
    428         self = CN2UnorderedLearner.__new__(cls, **kwargs) 
    429         if examples is not None: 
    430             self.__init__(**kwargs) 
    431             return self.__call__(examples, weightID) 
    432         else: 
    433             return self 
    434          
    435     def __init__(self, evaluator = WRACCEvaluator(), beamWidth = 5, alpha = 0.05, mult=0.7, **kwds): 
    436         CN2UnorderedLearnerClass.__init__(self, evaluator = evaluator, 
    437                                           beamWidth = beamWidth, alpha = alpha, **kwds) 
    438         self.coverAndRemove = CovererAndRemover_multWeights(mult=mult) 
    439  
    440     def __call__(self, examples, weight=0):         
    441         supervisedClassCheck(examples) 
    442          
    443         oldExamples = orange.ExampleTable(examples) 
    444         classifier = CN2UnorderedLearnerClass.__call__(self,examples,weight) 
    445         for r in classifier.rules: 
    446             r.filterAndStore(oldExamples,weight,r.classifier.defaultVal) 
    447         return classifier 
    448  
    449 # Miscellaneous - utility functions 
    450 def avg(l): 
    451     if len(l)==0: 
    452         return 0. 
    453     return sum(l)/len(l) 
    454  
    455 def var(l): 
    456     if len(l)<2: 
    457         return 0. 
    458     av = avg(l) 
    459     vars=[math.pow(li-av,2) for li in l] 
    460     return sum(vars)/(len(l)-1) 
    461  
    462 def median(l): 
    463     if len(l)==0: 
    464         return 0.     
    465     l.sort() 
    466     le = len(l) 
    467     if le%2 == 1: 
    468         return l[(le-1)/2] 
    469     else: 
    470         return (l[le/2-1]+l[le/2])/2 
    471  
    472 def perc(l,p): 
    473     l.sort() 
    474     return l[int(math.floor(p*len(l)))] 
    475  
    476 def createRandomDataSet(data): 
    477     newData = orange.ExampleTable(data) 
    478     # shuffle data 
    479     cl_num = newData.toNumeric("C") 
    480     random.shuffle(cl_num[0][:,0]) 
    481     clData = orange.ExampleTable(orange.Domain([newData.domain.classVar]),cl_num[0]) 
    482     for d_i,d in enumerate(newData): 
    483         d[newData.domain.classVar] = clData[d_i][newData.domain.classVar] 
    484     return newData 
    485  
    486 # estimated fisher tippett parameters for a set of values given in vals list (+ deciles) 
    487 def compParameters(vals,oldMi=0.5,oldBeta=1.1):                     
    488     # compute percentiles 
    489     vals.sort() 
    490     N = len(vals) 
    491     percs = [avg(vals[int(float(N)*i/10):int(float(N)*(i+1)/10)]) for i in range(10)]             
    492     if N<10: 
    493         return oldMi, oldBeta, percs 
    494     beta = math.sqrt(6*var(vals)/math.pow(math.pi,2)) 
    495     beta = min(2.0,max(oldBeta, beta)) 
    496     mi = max(oldMi, avg(vals) - 0.57721*beta) 
    497     return mi, beta, percs 
    498  
    499  
    500 def computeDists(data, weight=0, targetClass=0, N=100, learner=None): 
    501     """ Compute distributions of likelihood ratio statistics of extreme (best) rules.  """ 
    502     if not learner: 
    503         learner = createLearner() 
    504  
    505     ######################### 
    506     ## Learner preparation ## 
    507     ######################### 
    508     oldStopper = learner.ruleFinder.ruleStoppingValidator 
    509     evaluator = learner.ruleFinder.evaluator 
    510     learner.ruleFinder.evaluator = orange.RuleEvaluator_LRS() 
    511     learner.ruleFinder.evaluator.storeRules = True 
    512     learner.ruleFinder.ruleStoppingValidator = orange.RuleValidator_LRS(alpha=1.0) 
    513     learner.ruleFinder.ruleStoppingValidator.max_rule_complexity = 0   
    514  
    515     # loop through N (sampling repetitions) 
    516     maxVals = [] 
    517     for d_i in range(N): 
    518         # create data set (remove and randomize) 
    519         tempData = createRandomDataSet(data) 
    520         learner.ruleFinder.evaluator.rules = orange.RuleList() 
    521         # Next, learn a rule 
    522         bestRule = learner.ruleFinder(tempData,weight,targetClass,orange.RuleList()) 
    523         maxVals.append(bestRule.quality) 
    524     extremeDists=[compParameters(maxVals,1.0,1.0)] 
    525  
    526     ##################### 
    527     ## Restore learner ## 
    528     ##################### 
    529     learner.ruleFinder.evaluator = evaluator 
    530     learner.ruleFinder.ruleStoppingValidator = oldStopper 
    531     return extremeDists 
    532  
    533 def createEVDistList(evdList): 
    534     l = orange.EVDistList() 
    535     for el in evdList: 
    536         l.append(orange.EVDist(mu=el[0],beta=el[1],percentiles=el[2])) 
    537     return l 
    538  
    539 class CovererAndRemover_Prob(orange.RuleCovererAndRemover): 
    540     """ This class impements probabilistic covering. """ 
    541     def __init__(self, probAttribute=None, sigAttribute=None): 
    542         self.indices = None 
    543         self.probAttribute = probAttribute 
    544         self.bestRule = [] 
    545  
    546     def initialize(self, examples, weightID, targetClass, apriori): 
    547         self.bestRule = [None]*len(examples) 
    548         self.probAttribute = orange.newmetaid() 
    549         examples.addMetaAttribute(self.probAttribute,-1.e-6) 
    550         examples.domain.addmeta(self.probAttribute, orange.FloatVariable("Probs")) 
    551         for example in examples: 
    552 ##            if targetClass<0 or (example.getclass() == targetClass): 
    553             example[self.probAttribute] = apriori[targetClass]/apriori.abs 
    554         return examples 
    555  
    556     def getBestRules(self, currentRules, examples, weightID): 
    557         bestRules = orange.RuleList() 
    558         for r in currentRules: 
    559             if hasattr(r.learner, "argumentRule") and not orngCN2.rule_in_set(r,bestRules): 
    560                 bestRules.append(r) 
    561         for r_i,r in enumerate(self.bestRule): 
    562             if r and not rule_in_set(r,bestRules) and examples[r_i].getclass()==r.classifier.defaultValue: 
    563                 bestRules.append(r) 
    564         return bestRules 
    565  
    566     def remainingExamplesP(self, examples, targetClass): 
    567         pSum, pAll = 0.0, 0.0 
    568         for ex in examples: 
    569             if ex.getclass() == targetClass: 
    570                 pSum += ex[self.probAttribute] 
    571                 pAll += 1.0 
    572         return pSum/pAll 
    573  
    574     def __call__(self, rule, examples, weights, targetClass): 
    575         if targetClass<0: 
    576             for example_i, example in enumerate(examples): 
    577                 if rule(example) and rule.quality>example[self.probAttribute]-0.01: 
    578                     example[self.probAttribute] = rule.quality+0.01 
    579                     self.bestRule[example_i]=rule 
    580         else: 
    581             for example_i, example in enumerate(examples): #rule.classifier.defaultVal == example.getclass() and 
    582                 if rule(example) and rule.quality>example[self.probAttribute]: 
    583                     example[self.probAttribute] = rule.quality+0.001 
    584                     self.bestRule[example_i]=rule 
    585 ##                if rule.classifier.defaultVal == example.getclass(): 
    586 ##                    print example[self.probAttribute] 
    587         # compute factor 
    588         return (examples,weights) 
    589  
    590 def add_sub_rules(rules, examples, weight, learner, dists): 
    591     apriori = orange.Distribution(examples.domain.classVar,examples,weight) 
    592     newRules = orange.RuleList() 
    593     for r in rules: 
    594         newRules.append(r) 
    595  
    596     # loop through rules 
    597     for r in rules: 
    598         tmpList = orange.RuleList() 
    599         tmpRle = r.clone() 
    600         tmpRle.filter.conditions = [] 
    601         tmpRle.parentRule = None 
    602         tmpRle.filterAndStore(examples,weight,r.classifier.defaultVal) 
    603         tmpList.append(tmpRle) 
    604         while tmpList and len(tmpList[0].filter.conditions) <= len(r.filter.conditions): 
    605             tmpList2 = orange.RuleList() 
    606             for tmpRule in tmpList: 
    607                 # evaluate tmpRule 
    608                 oldREP = learner.ruleFinder.evaluator.returnExpectedProb 
    609                 learner.ruleFinder.evaluator.returnExpectedProb = False 
    610                 learner.ruleFinder.evaluator.evDistGetter.dists = createEVDistList(dists[int(r.classifier.defaultVal)]) 
    611                 tmpRule.quality = learner.ruleFinder.evaluator(tmpRule,examples,weight,r.classifier.defaultVal,apriori) 
    612                 learner.ruleFinder.evaluator.returnExpectedProb = oldREP 
    613                 # if rule not in rules already, add it to the list 
    614                 if not True in [rules_equal(ri,tmpRule) for ri in newRules] and len(tmpRule.filter.conditions)>0 and tmpRule.quality > apriori[r.classifier.defaultVal]/apriori.abs: 
    615                     newRules.append(tmpRule) 
    616                 # create new tmpRules, set parent Rule, append them to tmpList2 
    617                 if not True in [rules_equal(ri,tmpRule) for ri in newRules]: 
    618                     for c in r.filter.conditions: 
    619                         tmpRule2 = tmpRule.clone() 
    620                         tmpRule2.parentRule = tmpRule 
    621                         tmpRule2.filter.conditions.append(c) 
    622                         tmpRule2.filterAndStore(examples,weight,r.classifier.defaultVal) 
    623                         if tmpRule2.classDistribution.abs < tmpRule.classDistribution.abs: 
    624                             tmpList2.append(tmpRule2) 
    625             tmpList = tmpList2 
    626     for cl in examples.domain.classVar: 
    627         tmpRle = orange.Rule() 
    628         tmpRle.filter = orange.Filter_values(domain = examples.domain) 
    629         tmpRle.parentRule = None 
    630         tmpRle.filterAndStore(examples,weight,int(cl)) 
    631         tmpRle.quality = tmpRle.classDistribution[int(cl)]/tmpRle.classDistribution.abs 
    632         newRules.append(tmpRle) 
    633     return newRules 
    634  
    635 #def CN2EVCUnorderedLearner(examples = None, weightID=0, **kwds): 
    636 #    cn2 = CN2EVCUnorderedLearnerClass(**kwds) 
    637 #    if examples: 
    638 #        return cn2(examples, weightID) 
    639 #    else: 
    640 #        return cn2 
    641      
    642 class CN2EVCUnorderedLearner(ABCN2): 
    643     """This is implementation of CN2 + EVC as evaluation + LRC classification. 
    644         Main parameters: 
    645           -- ... 
    646     """ 
    647     def __init__(self, width=5, nsampling=100, rule_sig=1.0, att_sig=1.0, min_coverage = 1., max_rule_complexity = 5.): 
    648         ABCN2.__init__(self, width=width, nsampling=nsampling, rule_sig=rule_sig, att_sig=att_sig, 
    649                        min_coverage=int(min_coverage), max_rule_complexity = int(max_rule_complexity)) 
    650  
    651                       
    652          
     1from Orange.classification.rules import ruleToString 
     2from Orange.classification.rules import LaplaceEvaluator 
     3from Orange.classification.rules import WRACCEvaluator 
     4from Orange.classification.rules import mEstimate 
     5from Orange.classification.rules import RuleStopping_apriori 
     6from Orange.classification.rules import LengthValidator 
     7from Orange.classification.rules import supervisedClassCheck 
     8from Orange.classification.rules import CN2Learner 
     9from Orange.classification.rules import CN2Classifier 
     10from Orange.classification.rules import CN2UnorderedLearner 
     11from Orange.classification.rules import CN2UnorderedClassifier 
     12from Orange.classification.rules import RuleClassifier_bestRule 
     13from Orange.classification.rules import CovererAndRemover_multWeights 
     14from Orange.classification.rules import CovererAndRemover_addWeights 
     15from Orange.classification.rules import rule_in_set 
     16from Orange.classification.rules import rules_equal 
     17from Orange.classification.rules import noDuplicates_validator 
     18from Orange.classification.rules import ruleSt_setRules 
     19from Orange.classification.rules import CN2SDUnorderedLearner 
     20from Orange.classification.rules import avg 
     21from Orange.classification.rules import var 
     22from Orange.classification.rules import median 
     23from Orange.classification.rules import perc 
     24from Orange.classification.rules import createRandomDataSet 
     25from Orange.classification.rules import compParameters                     
     26from Orange.classification.rules import computeDists 
     27from Orange.classification.rules import createEVDistList 
     28from Orange.classification.rules import CovererAndRemover_Prob 
     29from Orange.classification.rules import add_sub_rules 
     30from Orange.classification.rules import CN2EVCUnorderedLearner 
Note: See TracChangeset for help on using the changeset viewer.