Ignore:
Timestamp:
02/06/12 15:34:08 (2 years ago)
Author:
Miha Stajdohar <miha.stajdohar@…>
Branch:
default
rebase_source:
f13e7c137e40d752e9894911f66e4a30c9c6d85b
Message:

Added create_dichotomous_class.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • Orange/classification/rules.py

    r9701 r9738  
    611611 
    612612 
     613class ConvertClass: 
     614    """ Converting class variables into dichotomous class variable. """ 
     615    def __init__(self, classAtt, classValue, newClassAtt): 
     616        self.classAtt = classAtt 
     617        self.classValue = classValue 
     618        self.newClassAtt = newClassAtt 
     619 
     620    def __call__(self, example, returnWhat): 
     621        if example[self.classAtt] == self.classValue: 
     622            return Orange.data.Value(self.newClassAtt, self.classValue + "_") 
     623        else: 
     624            return Orange.data.Value(self.newClassAtt, "not " + self.classValue) 
     625 
     626 
     627def create_dichotomous_class(domain, att, value, negate, removeAtt=None): 
     628    # create new variable 
     629    newClass = Orange.data.variable.Discrete(att.name + "_", values=[str(value) + "_", "not " + str(value)]) 
     630    positive = Orange.data.Value(newClass, str(value) + "_") 
     631    negative = Orange.data.Value(newClass, "not " + str(value)) 
     632    newClass.getValueFrom = ConvertClass(att, str(value), newClass) 
     633 
     634    att = [a for a in domain.attributes] 
     635    newDomain = Orange.data.Domain(att + [newClass]) 
     636    newDomain.addmetas(domain.getmetas()) 
     637    if negate == 1: 
     638        return (newDomain, negative) 
     639    else: 
     640        return (newDomain, positive) 
     641 
     642 
    613643class LaplaceEvaluator(RuleEvaluator): 
    614644    """ 
     
    619649            return 0. 
    620650        sumDist = rule.class_distribution.cases 
    621         if not sumDist or (target_class>-1 and not rule.class_distribution[target_class]): 
     651        if not sumDist or (target_class > -1 and not rule.class_distribution[target_class]): 
    622652            return 0. 
    623653        # get distribution 
    624         if target_class>-1: 
    625             return (rule.class_distribution[target_class]+1)/(sumDist+2) 
     654        if target_class > -1: 
     655            return (rule.class_distribution[target_class] + 1) / (sumDist + 2) 
    626656        else: 
    627             return (max(rule.class_distribution)+1)/(sumDist+len(data.domain.class_var.values)) 
     657            return (max(rule.class_distribution) + 1) / (sumDist + len(data.domain.class_var.values)) 
    628658 
    629659LaplaceEvaluator = deprecated_members({"weightID": "weight_id", 
     
    639669            return 0. 
    640670        sumDist = rule.class_distribution.cases 
    641         if not sumDist or (target_class>-1 and not rule.class_distribution[target_class]): 
     671        if not sumDist or (target_class > -1 and not rule.class_distribution[target_class]): 
    642672            return 0. 
    643673        # get distribution 
    644         if target_class>-1: 
    645             pRule = rule.class_distribution[target_class]/apriori[target_class] 
    646             pTruePositive = rule.class_distribution[target_class]/sumDist 
    647             pClass = apriori[target_class]/apriori.cases 
     674        if target_class > -1: 
     675            pRule = rule.class_distribution[target_class] / apriori[target_class] 
     676            pTruePositive = rule.class_distribution[target_class] / sumDist 
     677            pClass = apriori[target_class] / apriori.cases 
    648678        else: 
    649             pRule = sumDist/apriori.cases 
    650             pTruePositive = max(rule.class_distribution)/sumDist 
    651             pClass = apriori[rule.class_distribution.modus()]/sum(apriori) 
    652         if pTruePositive>pClass: 
    653             return pRule*(pTruePositive-pClass) 
    654         else: return (pTruePositive-pClass)/max(pRule,1e-6) 
     679            pRule = sumDist / apriori.cases 
     680            pTruePositive = max(rule.class_distribution) / sumDist 
     681            pClass = apriori[rule.class_distribution.modus()] / sum(apriori) 
     682        if pTruePositive > pClass: 
     683            return pRule * (pTruePositive - pClass) 
     684        else: return (pTruePositive - pClass) / max(pRule, 1e-6) 
    655685 
    656686WRACCEvaluator = deprecated_members({"weightID": "weight_id", 
     
    675705            return 0. 
    676706        # get distribution 
    677         if target_class>-1: 
    678             p = rule.class_distribution[target_class]+self.m*apriori[target_class]/apriori.abs 
     707        if target_class > -1: 
     708            p = rule.class_distribution[target_class] + self.m * apriori[target_class] / apriori.abs 
    679709            p = p / (rule.class_distribution.abs + self.m) 
    680710        else: 
    681             p = max(rule.class_distribution)+self.m*apriori[rule.\ 
    682                 class_distribution.modus()]/apriori.abs 
    683             p = p / (rule.class_distribution.abs + self.m)       
     711            p = max(rule.class_distribution) + self.m * apriori[rule.\ 
     712                class_distribution.modus()] / apriori.abs 
     713            p = p / (rule.class_distribution.abs + self.m) 
    684714        return p 
    685715 
     
    707737 
    708738    """ 
    709      
     739 
    710740    def __new__(cls, instances=None, weight_id=0, **kwargs): 
    711741        self = RuleLearner.__new__(cls, **kwargs) 
     
    715745        else: 
    716746            return self 
    717          
    718     def __init__(self, evaluator = RuleEvaluator_Entropy(), beam_width = 5, 
    719         alpha = 1.0, **kwds): 
     747 
     748    def __init__(self, evaluator=RuleEvaluator_Entropy(), beam_width=5, 
     749        alpha=1.0, **kwds): 
    720750        self.__dict__.update(kwds) 
    721751        self.rule_finder = RuleBeamFinder() 
    722         self.rule_finder.ruleFilter = RuleBeamFilter_Width(width = beam_width) 
     752        self.rule_finder.ruleFilter = RuleBeamFilter_Width(width=beam_width) 
    723753        self.rule_finder.evaluator = evaluator 
    724         self.rule_finder.validator = RuleValidator_LRS(alpha = alpha) 
    725          
     754        self.rule_finder.validator = RuleValidator_LRS(alpha=alpha) 
     755 
    726756    def __call__(self, instances, weight=0): 
    727757        supervisedClassCheck(instances) 
    728          
    729         cl = RuleLearner.__call__(self,instances,weight) 
     758 
     759        cl = RuleLearner.__call__(self, instances, weight) 
    730760        rules = cl.rules 
    731761        return CN2Classifier(rules, instances, weight) 
     
    759789 
    760790    """ 
    761      
     791 
    762792    @deprecated_keywords({"examples": "instances"}) 
    763     def __init__(self, rules=None, instances=None, weight_id = 0, **argkw): 
     793    def __init__(self, rules=None, instances=None, weight_id=0, **argkw): 
    764794        self.rules = rules 
    765795        self.examples = instances 
     
    768798        self.__dict__.update(argkw) 
    769799        if instances is not None: 
    770             self.prior = Orange.statistics.distribution.Distribution(instances.domain.class_var,instances) 
     800            self.prior = Orange.statistics.distribution.Distribution(instances.domain.class_var, instances) 
    771801 
    772802    def __call__(self, instance, result_type=Orange.classification.Classifier.GetValue): 
     
    790820                break 
    791821        if not classifier: 
    792             classifier = Orange.classification.ConstantClassifier(instance.domain.class_var,\ 
     822            classifier = Orange.classification.ConstantClassifier(instance.domain.class_var, \ 
    793823                self.prior.modus()) 
    794824            classifier.defaultDistribution = self.prior 
     
    799829        if result_type == Orange.classification.Classifier.GetProbabilities: 
    800830          return classifier.default_distribution 
    801         return (classifier(instance),classifier.default_distribution) 
     831        return (classifier(instance), classifier.default_distribution) 
    802832 
    803833    def __str__(self): 
    804         ret_str = rule_to_string(self.rules[0])+" "+str(self.rules[0].\ 
    805             class_distribution)+"\n" 
     834        ret_str = rule_to_string(self.rules[0]) + " " + str(self.rules[0].\ 
     835            class_distribution) + "\n" 
    806836        for r in self.rules[1:]: 
    807             ret_str += "ELSE "+rule_to_string(r)+" "+str(r.class_distribution)+"\n" 
     837            ret_str += "ELSE " + rule_to_string(r) + " " + str(r.class_distribution) + "\n" 
    808838        return ret_str 
    809839 
     
    839869        else: 
    840870            return self 
    841              
    842     def __init__(self, evaluator = RuleEvaluator_Laplace(), beam_width = 5, 
    843         alpha = 1.0, **kwds): 
     871 
     872    def __init__(self, evaluator=RuleEvaluator_Laplace(), beam_width=5, 
     873        alpha=1.0, **kwds): 
    844874        self.__dict__.update(kwds) 
    845875        self.rule_finder = RuleBeamFinder() 
    846         self.rule_finder.ruleFilter = RuleBeamFilter_Width(width = beam_width) 
     876        self.rule_finder.ruleFilter = RuleBeamFilter_Width(width=beam_width) 
    847877        self.rule_finder.evaluator = evaluator 
    848         self.rule_finder.validator = RuleValidator_LRS(alpha = alpha) 
    849         self.rule_finder.rule_stoppingValidator = RuleValidator_LRS(alpha = 1.0) 
     878        self.rule_finder.validator = RuleValidator_LRS(alpha=alpha) 
     879        self.rule_finder.rule_stoppingValidator = RuleValidator_LRS(alpha=1.0) 
    850880        self.rule_stopping = RuleStopping_Apriori() 
    851881        self.data_stopping = RuleDataStoppingCriteria_NoPositives() 
    852      
     882 
    853883    @deprecated_keywords({"weight": "weight_id"}) 
    854884    def __call__(self, instances, weight_id=0): 
    855885        supervisedClassCheck(instances) 
    856          
     886 
    857887        rules = RuleList() 
    858888        self.rule_stopping.apriori = Orange.statistics.distribution.Distribution( 
    859             instances.domain.class_var,instances) 
    860         progress=getattr(self,"progressCallback",None) 
     889            instances.domain.class_var, instances) 
     890        progress = getattr(self, "progressCallback", None) 
    861891        if progress: 
    862892            progress.start = 0.0 
     
    870900                progress.end += distrib[target_class] 
    871901            self.target_class = target_class 
    872             cl = RuleLearner.__call__(self,instances,weight_id) 
     902            cl = RuleLearner.__call__(self, instances, weight_id) 
    873903            for r in cl.rules: 
    874904                rules.append(r) 
    875905        if progress: 
    876             progress(1.0,None) 
     906            progress(1.0, None) 
    877907        return CN2UnorderedClassifier(rules, instances, weight_id) 
    878908 
     
    907937 
    908938    @deprecated_keywords({"examples": "instances"}) 
    909     def __init__(self, rules = None, instances = None, weight_id = 0, **argkw): 
     939    def __init__(self, rules=None, instances=None, weight_id=0, **argkw): 
    910940        self.rules = rules 
    911941        self.examples = instances 
     
    918948 
    919949    @deprecated_keywords({"retRules": "ret_rules"}) 
    920     def __call__(self, instance, result_type=Orange.classification.Classifier.GetValue, ret_rules = False): 
     950    def __call__(self, instance, result_type=Orange.classification.Classifier.GetValue, ret_rules=False): 
    921951        """ 
    922952        :param instance: instance to be classified. 
     
    933963            disc = Orange.statistics.distribution.Discrete(disc1) 
    934964            sumdisc = sumd 
    935             for i,d in enumerate(disc): 
    936                 disc[i]+=disc2[i] 
     965            for i, d in enumerate(disc): 
     966                disc[i] += disc2[i] 
    937967                sumdisc += disc2[i] 
    938968            return disc, sumdisc 
     
    950980            retDist = self.prior 
    951981            sumdisc = self.prior.abs 
    952              
     982 
    953983        if sumdisc > 0.0: 
    954984            for c in self.examples.domain.class_var: 
     
    956986        else: 
    957987            retDist.normalize() 
    958          
     988 
    959989        if ret_rules: 
    960990            if result_type == Orange.classification.Classifier.GetValue: 
     
    962992            if result_type == Orange.classification.Classifier.GetProbabilities: 
    963993              return (retDist, covRules) 
    964             return (retDist.modus(),retDist,covRules) 
     994            return (retDist.modus(), retDist, covRules) 
    965995        if result_type == Orange.classification.Classifier.GetValue: 
    966996          return retDist.modus() 
    967997        if result_type == Orange.classification.Classifier.GetProbabilities: 
    968998          return retDist 
    969         return (retDist.modus(),retDist) 
     999        return (retDist.modus(), retDist) 
    9701000 
    9711001    def __str__(self): 
    9721002        retStr = "" 
    9731003        for r in self.rules: 
    974             retStr += rule_to_string(r)+" "+str(r.class_distribution)+"\n" 
     1004            retStr += rule_to_string(r) + " " + str(r.class_distribution) + "\n" 
    9751005        return retStr 
    9761006 
     
    10121042        else: 
    10131043            return self 
    1014          
    1015     def __init__(self, evaluator = WRACCEvaluator(), beam_width = 5, 
    1016                 alpha = 0.05, mult=0.7, **kwds): 
    1017         CN2UnorderedLearner.__init__(self, evaluator = evaluator, 
    1018                                           beam_width = beam_width, alpha = alpha, **kwds) 
     1044 
     1045    def __init__(self, evaluator=WRACCEvaluator(), beam_width=5, 
     1046                alpha=0.05, mult=0.7, **kwds): 
     1047        CN2UnorderedLearner.__init__(self, evaluator=evaluator, 
     1048                                          beam_width=beam_width, alpha=alpha, **kwds) 
    10191049        self.cover_and_remove = CovererAndRemover_MultWeights(mult=mult) 
    10201050 
    1021     def __call__(self, instances, weight=0):         
     1051    def __call__(self, instances, weight=0): 
    10221052        supervisedClassCheck(instances) 
    1023          
     1053 
    10241054        oldInstances = Orange.data.Table(instances) 
    1025         classifier = CN2UnorderedLearner.__call__(self,instances,weight) 
     1055        classifier = CN2UnorderedLearner.__call__(self, instances, weight) 
    10261056        for r in classifier.rules: 
    1027             r.filterAndStore(oldInstances,weight,r.classifier.default_val) 
     1057            r.filterAndStore(oldInstances, weight, r.classifier.default_val) 
    10281058        return classifier 
    10291059 
     
    10951125 
    10961126    """ 
    1097      
     1127 
    10981128    def __init__(self, argument_id=0, width=5, m=2, opt_reduction=2, nsampling=100, max_rule_complexity=5, 
    10991129                 rule_sig=1.0, att_sig=1.0, postpruning=None, min_quality=0., min_coverage=1, min_improved=1, min_improved_perc=0.0, 
    1100                  learn_for_class = None, learn_one_rule = False, evd=None, evd_arguments=None, prune_arguments=False, analyse_argument=-1, 
    1101                  alternative_learner = None, min_cl_sig = 0.5, min_beta = 0.0, set_prefix_rules = False, add_sub_rules = False, debug=False, 
     1130                 learn_for_class=None, learn_one_rule=False, evd=None, evd_arguments=None, prune_arguments=False, analyse_argument= -1, 
     1131                 alternative_learner=None, min_cl_sig=0.5, min_beta=0.0, set_prefix_rules=False, add_sub_rules=False, debug=False, 
    11021132                 **kwds): 
    1103          
     1133 
    11041134        # argument ID which is passed to abcn2 learner 
    11051135        self.argument_id = argument_id 
     
    11171147        if max_rule_complexity - 1 < 0: 
    11181148            max_rule_complexity = 10 
    1119         self.rule_finder.rule_stoppingValidator = RuleValidator_LRS(alpha = 1.0, min_quality = 0., max_rule_complexity = max_rule_complexity - 1, min_coverage=min_coverage) 
     1149        self.rule_finder.rule_stoppingValidator = RuleValidator_LRS(alpha=1.0, min_quality=0., max_rule_complexity=max_rule_complexity - 1, min_coverage=min_coverage) 
    11201150        self.refiner = RuleBeamRefiner_Selector() 
    1121         self.refiner_arguments = SelectorAdder(discretizer = Orange.feature.discretization.EntropyDiscretization(forceAttribute = 1, 
    1122                                                                                            maxNumberOfIntervals = 2)) 
     1151        self.refiner_arguments = SelectorAdder(discretizer=Orange.feature.discretization.EntropyDiscretization(forceAttribute=1, 
     1152                                                                                           maxNumberOfIntervals=2)) 
    11231153        self.prune_arguments = prune_arguments 
    11241154        # evc evaluator 
    11251155        evdGet = Orange.core.EVDistGetter_Standard() 
    1126         self.rule_finder.evaluator = RuleEvaluator_mEVC(m=m, evDistGetter = evdGet, min_improved = min_improved, min_improved_perc = min_improved_perc) 
     1156        self.rule_finder.evaluator = RuleEvaluator_mEVC(m=m, evDistGetter=evdGet, min_improved=min_improved, min_improved_perc=min_improved_perc) 
    11271157        self.rule_finder.evaluator.returnExpectedProb = True 
    11281158        self.rule_finder.evaluator.optimismReduction = opt_reduction 
    11291159        self.rule_finder.evaluator.ruleAlpha = rule_sig 
    11301160        self.rule_finder.evaluator.attributeAlpha = att_sig 
    1131         self.rule_finder.evaluator.validator = RuleValidator_LRS(alpha = 1.0, min_quality = min_quality, min_coverage=min_coverage, max_rule_complexity = max_rule_complexity - 1) 
     1161        self.rule_finder.evaluator.validator = RuleValidator_LRS(alpha=1.0, min_quality=min_quality, min_coverage=min_coverage, max_rule_complexity=max_rule_complexity - 1) 
    11321162 
    11331163        # learn stopping criteria 
     
    11351165        self.data_stopping = RuleDataStoppingCriteria_NoPositives() 
    11361166        # evd fitting 
    1137         self.evd_creator = EVDFitter(self,n=nsampling) 
     1167        self.evd_creator = EVDFitter(self, n=nsampling) 
    11381168        self.evd = evd 
    11391169        self.evd_arguments = evd_arguments 
    11401170        # classifier 
    11411171        self.add_sub_rules = add_sub_rules 
    1142         self.classifier = PILAR(alternative_learner = alternative_learner, min_cl_sig = min_cl_sig, min_beta = min_beta, set_prefix_rules = set_prefix_rules) 
     1172        self.classifier = PILAR(alternative_learner=alternative_learner, min_cl_sig=min_cl_sig, min_beta=min_beta, set_prefix_rules=set_prefix_rules) 
    11431173        self.debug = debug 
    11441174        # arbitrary parameters 
     
    11481178    def __call__(self, examples, weight_id=0): 
    11491179        # initialize progress bar 
    1150         progress=getattr(self,"progressCallback",None) 
     1180        progress = getattr(self, "progressCallback", None) 
    11511181        if progress: 
    11521182            progress.start = 0.0 
     
    11551185                             examples.domain.class_var, examples, weight_id) 
    11561186            distrib.normalize() 
    1157          
     1187 
    11581188        # we begin with an empty set of rules 
    11591189        all_rules = RuleList() 
    11601190 
    11611191        # th en, iterate through all classes and learn rule for each class separately 
    1162         for cl_i,cl in enumerate(examples.domain.class_var): 
     1192        for cl_i, cl in enumerate(examples.domain.class_var): 
    11631193            if progress: 
    11641194                step = distrib[cl] / 2. 
    11651195                progress.start = progress.end 
    11661196                progress.end += step 
    1167                  
    1168             if self.learn_for_class and not self.learn_for_class in [cl,cl_i]: 
     1197 
     1198            if self.learn_for_class and not self.learn_for_class in [cl, cl_i]: 
    11691199                continue 
    11701200 
     
    11871217                progress.start = progress.end 
    11881218                progress.end += step 
    1189              
     1219 
    11901220            aes = self.get_argumented_examples(dich_data) 
    11911221            aes = self.sort_arguments(aes, dich_data) 
     
    12101240 
    12111241            if not progress and self.debug: 
    1212                 print " arguments finished ... "                     
    1213                     
     1242                print " arguments finished ... " 
     1243 
    12141244            # remove all examples covered by rules 
    12151245            for rule in rules: 
    12161246                dich_data = self.remove_covered_examples(rule, dich_data, weight_id) 
    12171247            if progress: 
    1218                 progress(self.remaining_probability(dich_data),None) 
     1248                progress(self.remaining_probability(dich_data), None) 
    12191249 
    12201250            # learn normal rules on remaining examples 
     
    12301260                    dich_data = self.remove_covered_examples(rule, dich_data, weight_id) 
    12311261                    if progress: 
    1232                         progress(self.remaining_probability(dich_data),None) 
     1262                        progress(self.remaining_probability(dich_data), None) 
    12331263                    rules.append(rule) 
    12341264                    if self.learn_one_rule: 
     
    12461276 
    12471277            if progress: 
    1248                 progress(1.0,None) 
     1278                progress(1.0, None) 
    12491279        # create a classifier from all rules         
    12501280        return self.create_classifier(all_rules, examples, weight_id) 
     
    12541284        positive_args = self.init_pos_args(ae, examples, weight_id) 
    12551285        if not positive_args: # something wrong 
    1256             raise "There is a problem with argumented example %s"%str(ae) 
     1286            raise "There is a problem with argumented example %s" % str(ae) 
    12571287            return None 
    12581288        negative_args = self.init_neg_args(ae, examples, weight_id) 
     
    12621292        self.rule_finder.refiner.example = ae 
    12631293        # set arguments to filter 
    1264         self.rule_finder.ruleFilter.setArguments(examples.domain,positive_args) 
     1294        self.rule_finder.ruleFilter.setArguments(examples.domain, positive_args) 
    12651295 
    12661296        # learn a rule 
    12671297        self.rule_finder.evaluator.bestRule = None 
    1268         self.rule_finder(examples,weight_id, 0, positive_args) 
    1269          
     1298        self.rule_finder(examples, weight_id, 0, positive_args) 
     1299 
    12701300        # return best rule 
    12711301        return self.rule_finder.evaluator.bestRule 
    1272          
     1302 
    12731303    def prepare_settings(self, examples, weight_id, cl_i, progress): 
    12741304        # apriori distribution 
    12751305        self.apriori = Orange.statistics.distribution.Distribution( 
    1276                                 examples.domain.class_var,examples,weight_id) 
    1277          
     1306                                examples.domain.class_var, examples, weight_id) 
     1307 
    12781308        # prepare covering mechanism 
    12791309        self.coverAndRemove = CovererAndRemover_Prob(examples, weight_id, 0, self.apriori, self.argument_id) 
     
    12831313        # TODO: why evd and evd_this???? 
    12841314        if self.rule_finder.evaluator.optimismReduction > 0 and not self.evd: 
    1285             self.evd_this = self.evd_creator.computeEVD(examples, weight_id, target_class=0, progress = progress) 
     1315            self.evd_this = self.evd_creator.computeEVD(examples, weight_id, target_class=0, progress=progress) 
    12861316        if self.evd: 
    12871317            self.evd_this = self.evd[cl_i] 
     
    13031333        Create dichotomous class. 
    13041334        """ 
    1305         (newDomain, targetVal) = createDichotomousClass(examples.domain, examples.domain.class_var, str(cl), negate=0) 
     1335        (newDomain, targetVal) = create_dichotomous_class(examples.domain, examples.domain.class_var, str(cl), negate=0) 
    13061336        newDomainmetas = newDomain.getmetas() 
    13071337        newDomain.addmeta(Orange.data.new_meta_id(), examples.domain.class_var) # old class as meta 
     
    13161346        if not self.argument_id: 
    13171347            return None 
    1318          
     1348 
    13191349        # get argumented examples 
    1320         return ArgumentFilter_hasSpecial()(examples, self.argument_id, target_class = 0) 
     1350        return ArgumentFilter_hasSpecial()(examples, self.argument_id, target_class=0) 
    13211351 
    13221352    def sort_arguments(self, arg_examples, examples): 
     
    13241354            return None 
    13251355        evaluateAndSortArguments(examples, self.argument_id) 
    1326         if len(arg_examples)>0: 
     1356        if len(arg_examples) > 0: 
    13271357            # sort examples by their arguments quality (using first argument as it has already been sorted) 
    13281358            sorted = arg_examples.native() 
    1329             sorted.sort(lambda x,y: -cmp(x[self.argument_id].value.positive_arguments[0].quality, 
     1359            sorted.sort(lambda x, y:-cmp(x[self.argument_id].value.positive_arguments[0].quality, 
    13301360                                         y[self.argument_id].value.positive_arguments[0].quality)) 
    13311361            return Orange.data.Table(examples.domain, sorted) 
     
    13431373        self.rule_finder.refiner = self.refiner 
    13441374        self.rule_finder.ruleFilter = self.ruleFilter 
    1345          
     1375 
    13461376    def learn_normal_rule(self, examples, weight_id, apriori): 
    13471377        if hasattr(self.rule_finder.evaluator, "bestRule"): 
    13481378            self.rule_finder.evaluator.bestRule = None 
    1349         rule = self.rule_finder(examples,weight_id,0,RuleList()) 
     1379        rule = self.rule_finder(examples, weight_id, 0, RuleList()) 
    13501380        if hasattr(self.rule_finder.evaluator, "bestRule") and self.rule_finder.evaluator.returnExpectedProb: 
    13511381            rule = self.rule_finder.evaluator.bestRule 
    13521382            self.rule_finder.evaluator.bestRule = None 
    13531383        if self.postpruning: 
    1354             rule = self.postpruning(rule,examples,weight_id,0, aprior) 
     1384            rule = self.postpruning(rule, examples, weight_id, 0, aprior) 
    13551385        return rule 
    13561386 
    13571387    def remove_covered_examples(self, rule, examples, weight_id): 
    1358         nexamples, nweight = self.cover_and_remove(rule,examples,weight_id,0) 
     1388        nexamples, nweight = self.cover_and_remove(rule, examples, weight_id, 0) 
    13591389        return nexamples 
    13601390 
    13611391 
    13621392    def prune_unnecessary_rules(self, rules, examples, weight_id): 
    1363         return self.cover_and_remove.getBestRules(rules,examples,weight_id) 
     1393        return self.cover_and_remove.getBestRules(rules, examples, weight_id) 
    13641394 
    13651395    def change_domain(self, rule, cl, examples, weight_id): 
    1366         rule.filter = Orange.core.Filter_values(domain = examples.domain, 
    1367                                         conditions = rule.filter.conditions) 
    1368         rule.filterAndStore(examples, weight_id, cl)         
     1396        rule.filter = Orange.core.Filter_values(domain=examples.domain, 
     1397                                        conditions=rule.filter.conditions) 
     1398        rule.filterAndStore(examples, weight_id, cl) 
    13691399        if hasattr(rule, "learner") and hasattr(rule.learner, "arg_example"): 
    13701400            rule.learner.arg_example = Orange.data.Instance(examples.domain, rule.learner.arg_example) 
     
    13761406    def add_sub_rules_call(self, rules, examples, weight_id): 
    13771407        apriori = Orange.statistics.distribution.Distribution( 
    1378                             examples.domain.class_var,examples,weight_id) 
     1408                            examples.domain.class_var, examples, weight_id) 
    13791409        new_rules = RuleList() 
    13801410        for r in rules: 
     
    13871417            tmpRle.filter.conditions = r.filter.conditions[:r.requiredConditions] # do not split argument 
    13881418            tmpRle.parentRule = None 
    1389             tmpRle.filterAndStore(examples,weight_id,r.classifier.default_val) 
     1419            tmpRle.filterAndStore(examples, weight_id, r.classifier.default_val) 
    13901420            tmpRle.complexity = 0 
    13911421            tmpList.append(tmpRle) 
     
    13961426                    oldREP = self.rule_finder.evaluator.returnExpectedProb 
    13971427                    self.rule_finder.evaluator.returnExpectedProb = False 
    1398                     tmpRule.quality = self.rule_finder.evaluator(tmpRule,examples,weight_id,r.classifier.default_val,apriori) 
     1428                    tmpRule.quality = self.rule_finder.evaluator(tmpRule, examples, weight_id, r.classifier.default_val, apriori) 
    13991429                    self.rule_finder.evaluator.returnExpectedProb = oldREP 
    1400                 tmpList.sort(lambda x,y: -cmp(x.quality, y.quality)) 
     1430                tmpList.sort(lambda x, y:-cmp(x.quality, y.quality)) 
    14011431                tmpList = tmpList[:self.rule_filter.width] 
    1402                      
     1432 
    14031433                for tmpRule in tmpList: 
    14041434                    # if rule not in rules already, add it to the list 
    1405                     if not True in [Orange.classification.rules.rules_equal(ri,tmpRule) for ri in new_rules] and len(tmpRule.filter.conditions)>0 and tmpRule.quality > apriori[r.classifier.default_val]/apriori.abs: 
     1435                    if not True in [Orange.classification.rules.rules_equal(ri, tmpRule) for ri in new_rules] and len(tmpRule.filter.conditions) > 0 and tmpRule.quality > apriori[r.classifier.default_val] / apriori.abs: 
    14061436                        new_rules.append(tmpRule) 
    14071437                    # create new tmpRules, set parent Rule, append them to tmpList2 
    1408                     if not True in [Orange.classification.rules.rules_equal(ri,tmpRule) for ri in new_rules]: 
     1438                    if not True in [Orange.classification.rules.rules_equal(ri, tmpRule) for ri in new_rules]: 
    14091439                        for c in r.filter.conditions: 
    14101440                            tmpRule2 = tmpRule.clone() 
    14111441                            tmpRule2.parentRule = tmpRule 
    14121442                            tmpRule2.filter.conditions.append(c) 
    1413                             tmpRule2.filterAndStore(examples,weight_id,r.classifier.default_val) 
     1443                            tmpRule2.filterAndStore(examples, weight_id, r.classifier.default_val) 
    14141444                            tmpRule2.complexity += 1 
    14151445                            if tmpRule2.class_distribution.abs < tmprule.class_distribution.abs: 
     
    14221452        # prepare arguments 
    14231453        for p in ae[self.argument_id].value.positive_arguments: 
    1424             new_arg = Rule(filter=ArgFilter(argument_id = self.argument_id, 
    1425                                                    filter = self.newFilter_values(p.filter), 
    1426                                                    arg_example = ae), 
    1427                                                    complexity = 0) 
     1454            new_arg = Rule(filter=ArgFilter(argument_id=self.argument_id, 
     1455                                                   filter=self.newFilter_values(p.filter), 
     1456                                                   arg_example=ae), 
     1457                                                   complexity=0) 
    14281458            new_arg.valuesFilter = new_arg.filter.filter 
    14291459            pos_args.append(new_arg) 
     
    14331463            old_exp = self.rule_finder.evaluator.returnExpectedProb 
    14341464            self.rule_finder.evaluator.returnExpectedProb = False 
    1435              
     1465 
    14361466        # argument pruning (all or just unfinished arguments) 
    14371467        # if pruning is chosen, then prune arguments if possible 
     
    14471477                p.filter.conditions = pruned_conditions 
    14481478                p.learner.setattr("arg_length", 0) 
    1449                  
     1479 
    14501480            else: # prune only unspecified conditions 
    14511481                spec_conditions = [c for c in p.filter.conditions if not c.unspecialized_condition] 
     
    14651495                        # find minimum value 
    14661496                        if u.oper == Orange.core.ValueFilter_continuous.Greater or u.oper == Orange.core.ValueFilter_continuous.GreaterEqual: 
    1467                             u.ref = min([float(e[u.position])-10. for e in p.examples]) 
     1497                            u.ref = min([float(e[u.position]) - 10. for e in p.examples]) 
    14681498                        else: 
    1469                             u.ref = max([float(e[u.position])+10. for e in p.examples]) 
     1499                            u.ref = max([float(e[u.position]) + 10. for e in p.examples]) 
    14701500                        p.filter.conditions.append(u) 
    14711501                        p.filter.filter.conditions.append(u) 
    1472                  
     1502 
    14731503        # set parameters to arguments 
    1474         for p_i,p in enumerate(pos_args): 
    1475             p.filterAndStore(examples,weight_id,0) 
     1504        for p_i, p in enumerate(pos_args): 
     1505            p.filterAndStore(examples, weight_id, 0) 
    14761506            p.filter.domain = examples.domain 
    14771507            p.classifier = p.learner(p.examples, p.weightID) 
     
    14791509            p.learner.setattr("arg_example", ae) 
    14801510            p.complexity = len(p.filter.conditions) 
    1481              
     1511 
    14821512        if hasattr(self.rule_finder.evaluator, "returnExpectedProb"): 
    14831513            self.rule_finder.evaluator.returnExpectedProb = old_exp 
     
    15061536        cn2_learner.rule_finder.refiner = SelectorArgConditions(crit_example, allowed_conditions) 
    15071537        cn2_learner.rule_finder.evaluator = Orange.classification.rules.MEstimateEvaluator(self.rule_finder.evaluator.m) 
    1508         rule = cn2_learner.rule_finder(examples,weight_id,0,RuleList()) 
     1538        rule = cn2_learner.rule_finder(examples, weight_id, 0, RuleList()) 
    15091539        return rule.filter.conditions 
    15101540 
     
    15441574    :type mult: float 
    15451575    """ 
    1546     def __init__(self, width=5, nsampling=100, rule_sig=1.0, att_sig=1.0,\ 
    1547         min_coverage = 1., max_rule_complexity = 5.): 
     1576    def __init__(self, width=5, nsampling=100, rule_sig=1.0, att_sig=1.0, \ 
     1577        min_coverage=1., max_rule_complexity=5.): 
    15481578        ABCN2.__init__(self, width=width, nsampling=nsampling, 
    15491579            rule_sig=rule_sig, att_sig=att_sig, min_coverage=int(min_coverage), 
    1550             max_rule_complexity = int(max_rule_complexity)) 
     1580            max_rule_complexity=int(max_rule_complexity)) 
    15511581 
    15521582class DefaultLearner(Orange.core.Learner): 
     
    15541584    Default lerner - returns default classifier with predefined output class. 
    15551585    """ 
    1556     def __init__(self,default_value = None): 
     1586    def __init__(self, default_value=None): 
    15571587        self.default_value = default_value 
    1558     def __call__(self,examples,weight_id=0): 
    1559         return Orange.classification.majority.ConstantClassifier(self.default_value,defaultDistribution = Orange.core.Distribution(examples.domain.class_var,examples,weight_id)) 
     1588    def __call__(self, examples, weight_id=0): 
     1589        return Orange.classification.majority.ConstantClassifier(self.default_value, defaultDistribution=Orange.core.Distribution(examples.domain.class_var, examples, weight_id)) 
    15601590 
    15611591class ABCN2Ordered(ABCN2): 
     
    15751605        ABCN2.__init__(self, argument_id=argument_id, **kwds) 
    15761606        self.opt_reduction = 0 
    1577         self.rule_finder.evaluator.optimismReduction = self.opt_reduction         
     1607        self.rule_finder.evaluator.optimismReduction = self.opt_reduction 
    15781608        self.classifier = CN2UnorderedClassifier 
    15791609 
     
    15851615        ABCN2.__init__(self, argument_id=argument_id, **kwds) 
    15861616        self.opt_reduction = 0 
    1587         self.rule_finder.evaluator.optimismReduction = self.opt_reduction         
     1617        self.rule_finder.evaluator.optimismReduction = self.opt_reduction 
    15881618 
    15891619class ABCN2_StandardClassification(ABCN2): 
     
    15931623    def __init__(self, argument_id=0, **kwds): 
    15941624        ABCN2.__init__(self, argument_id=argument_id, **kwds) 
    1595         self.classifier = CN2UnorderedClassifier         
     1625        self.classifier = CN2UnorderedClassifier 
    15961626 
    15971627 
    15981628class RuleStopping_Apriori(RuleStoppingCriteria): 
    15991629    def __init__(self, apriori=None): 
    1600         self.apriori =  None 
    1601          
    1602     def __call__(self,rules,rule,instances,data): 
     1630        self.apriori = None 
     1631 
     1632    def __call__(self, rules, rule, instances, data): 
    16031633        if not self.apriori: 
    16041634            return False 
    16051635        if not type(rule.classifier) == Orange.classification.ConstantClassifier: 
    16061636            return False 
    1607         ruleAcc = rule.class_distribution[rule.classifier.default_val]/rule.class_distribution.abs 
    1608         aprioriAcc = self.apriori[rule.classifier.default_val]/self.apriori.abs 
    1609         if ruleAcc>aprioriAcc: 
     1637        ruleAcc = rule.class_distribution[rule.classifier.default_val] / rule.class_distribution.abs 
     1638        aprioriAcc = self.apriori[rule.classifier.default_val] / self.apriori.abs 
     1639        if ruleAcc > aprioriAcc: 
    16101640            return False 
    16111641        return True 
     
    16131643 
    16141644class RuleStopping_SetRules(RuleStoppingCriteria): 
    1615     def __init__(self,validator): 
     1645    def __init__(self, validator): 
    16161646        self.rule_stopping = RuleStoppingCriteria_NegativeDistribution() 
    16171647        self.validator = validator 
    16181648 
    1619     def __call__(self,rules,rule,instances,data):         
    1620         ru_st = self.rule_stopping(rules,rule,instances,data) 
     1649    def __call__(self, rules, rule, instances, data): 
     1650        ru_st = self.rule_stopping(rules, rule, instances, data) 
    16211651        if not ru_st: 
    16221652            self.validator.rules.append(rule) 
     
    16261656class LengthValidator(RuleValidator): 
    16271657    """ prune rules with more conditions than self.length. """ 
    1628     def __init__(self, length=-1): 
     1658    def __init__(self, length= -1): 
    16291659        self.length = length 
    1630          
     1660 
    16311661    def __call__(self, rule, data, weight_id, target_class, apriori): 
    16321662        if self.length >= 0: 
    16331663            return len(rule.filter.conditions) <= self.length 
    1634         return True     
     1664        return True 
    16351665 
    16361666 
    16371667class NoDuplicatesValidator(RuleValidator): 
    1638     def __init__(self,alpha=.05,min_coverage=0,max_rule_length=0,rules=RuleList()): 
     1668    def __init__(self, alpha=.05, min_coverage=0, max_rule_length=0, rules=RuleList()): 
    16391669        self.rules = rules 
    1640         self.validator = RuleValidator_LRS(alpha=alpha,\ 
    1641             min_coverage=min_coverage,max_rule_length=max_rule_length) 
    1642          
     1670        self.validator = RuleValidator_LRS(alpha=alpha, \ 
     1671            min_coverage=min_coverage, max_rule_length=max_rule_length) 
     1672 
    16431673    def __call__(self, rule, data, weight_id, target_class, apriori): 
    1644         if rule_in_set(rule,self.rules): 
     1674        if rule_in_set(rule, self.rules): 
    16451675            return False 
    1646         return bool(self.validator(rule,data,weight_id,target_class,apriori)) 
    1647                  
     1676        return bool(self.validator(rule, data, weight_id, target_class, apriori)) 
     1677 
    16481678 
    16491679 
    16501680class RuleClassifier_BestRule(RuleClassifier): 
    1651     def __init__(self, rules, instances, weight_id = 0, **argkw): 
     1681    def __init__(self, rules, instances, weight_id=0, **argkw): 
    16521682        self.rules = rules 
    16531683        self.examples = instances 
     
    16611691        bestRule = None 
    16621692        for r in self.rules: 
    1663             if r(instance) and (not bestRule or r.quality>bestRule.quality): 
    1664                 for v_i,v in enumerate(instance.domain.class_var): 
     1693            if r(instance) and (not bestRule or r.quality > bestRule.quality): 
     1694                for v_i, v in enumerate(instance.domain.class_var): 
    16651695                    retDist[v_i] = r.class_distribution[v_i] 
    16661696                bestRule = r 
     
    16801710        if result_type == Orange.classification.Classifier.GetProbabilities: 
    16811711          return retDist 
    1682         return (retDist.modus(),retDist) 
     1712        return (retDist.modus(), retDist) 
    16831713 
    16841714    def __str__(self): 
    16851715        retStr = "" 
    16861716        for r in self.rules: 
    1687             retStr += rule_to_string(r)+" "+str(r.class_distribution)+"\n" 
    1688         return retStr     
     1717            retStr += rule_to_string(r) + " " + str(r.class_distribution) + "\n" 
     1718        return retStr 
    16891719 
    16901720 
     
    16961726    :type mult: float     
    16971727    """ 
    1698      
    1699     def __init__(self, mult = 0.7): 
     1728 
     1729    def __init__(self, mult=0.7): 
    17001730        self.mult = mult 
    17011731    def __call__(self, rule, instances, weights, target_class): 
    17021732        if not weights: 
    17031733            weights = Orange.data.new_meta_id() 
    1704             instances.addMetaAttribute(weights,1.) 
     1734            instances.addMetaAttribute(weights, 1.) 
    17051735            instances.domain.addmeta(weights, Orange.data.variable.\ 
    1706                 Continuous("weights-"+str(weights)), True) 
     1736                Continuous("weights-" + str(weights)), True) 
    17071737        newWeightsID = Orange.data.new_meta_id() 
    1708         instances.addMetaAttribute(newWeightsID,1.) 
     1738        instances.addMetaAttribute(newWeightsID, 1.) 
    17091739        instances.domain.addmeta(newWeightsID, Orange.data.variable.\ 
    1710             Continuous("weights-"+str(newWeightsID)), True) 
     1740            Continuous("weights-" + str(newWeightsID)), True) 
    17111741        for instance in instances: 
    17121742            if rule(instance) and instance.getclass() == rule.classifier(\ 
    1713                 instance,Orange.classification.Classifier.GetValue): 
    1714                 instance[newWeightsID]=instance[weights]*self.mult 
     1743                instance, Orange.classification.Classifier.GetValue): 
     1744                instance[newWeightsID] = instance[weights] * self.mult 
    17151745            else: 
    1716                 instance[newWeightsID]=instance[weights] 
    1717         return (instances,newWeightsID) 
     1746                instance[newWeightsID] = instance[weights] 
     1747        return (instances, newWeightsID) 
    17181748 
    17191749 
     
    17231753     
    17241754    """ 
    1725      
     1755 
    17261756    def __call__(self, rule, instances, weights, target_class): 
    17271757        if not weights: 
    17281758            weights = Orange.data.new_meta_id() 
    1729             instances.addMetaAttribute(weights,1.) 
     1759            instances.addMetaAttribute(weights, 1.) 
    17301760            instances.domain.addmeta(weights, Orange.data.variable.\ 
    1731                 Continuous("weights-"+str(weights)), True) 
     1761                Continuous("weights-" + str(weights)), True) 
    17321762        try: 
    17331763            coverage = instances.domain.getmeta("Coverage") 
    17341764        except: 
    17351765            coverage = Orange.data.variable.Continuous("Coverage") 
    1736             instances.domain.addmeta(Orange.data.new_meta_id(),coverage, True) 
    1737             instances.addMetaAttribute(coverage,0.0) 
     1766            instances.domain.addmeta(Orange.data.new_meta_id(), coverage, True) 
     1767            instances.addMetaAttribute(coverage, 0.0) 
    17381768        newWeightsID = Orange.data.new_meta_id() 
    1739         instances.addMetaAttribute(newWeightsID,1.) 
     1769        instances.addMetaAttribute(newWeightsID, 1.) 
    17401770        instances.domain.addmeta(newWeightsID, Orange.data.variable.\ 
    1741             Continuous("weights-"+str(newWeightsID)), True) 
     1771            Continuous("weights-" + str(newWeightsID)), True) 
    17421772        for instance in instances: 
    1743             if rule(instance) and instance.getclass() == rule.classifier(instance,\ 
     1773            if rule(instance) and instance.getclass() == rule.classifier(instance, \ 
    17441774                    Orange.classification.Classifier.GetValue): 
    17451775                try: 
    1746                     instance[coverage]+=1.0 
     1776                    instance[coverage] += 1.0 
    17471777                except: 
    1748                     instance[coverage]=1.0 
    1749                 instance[newWeightsID]=1.0/(instance[coverage]+1) 
     1778                    instance[coverage] = 1.0 
     1779                instance[newWeightsID] = 1.0 / (instance[coverage] + 1) 
    17501780            else: 
    1751                 instance[newWeightsID]=instance[weights] 
    1752         return (instances,newWeightsID) 
     1781                instance[newWeightsID] = instance[weights] 
     1782        return (instances, newWeightsID) 
    17531783 
    17541784 
     
    17561786    """ This class impements probabilistic covering. """ 
    17571787    def __init__(self, examples, weight_id, target_class, apriori, argument_id): 
    1758         self.best_rule = [None]*len(examples) 
     1788        self.best_rule = [None] * len(examples) 
    17591789        self.prob_attribute = Orange.data.new_meta_id() 
    1760         self.apriori_prob = apriori[target_class]/apriori.abs 
     1790        self.apriori_prob = apriori[target_class] / apriori.abs 
    17611791        examples.addMetaAttribute(self.prob_attribute, self.apriori_prob) 
    1762         examples.domain.addmeta(self.prob_attribute,  
     1792        examples.domain.addmeta(self.prob_attribute, 
    17631793            Orange.data.variable.Continuous("Probs")) 
    17641794        self.argument_id = argument_id 
     
    17661796    def getBestRules(self, current_rules, examples, weight_id): 
    17671797        best_rules = RuleList() 
    1768         for r_i,r in enumerate(self.best_rule): 
    1769             if r and not rule_in_set(r,best_rules) and int(examples[r_i].getclass())==int(r.classifier.default_value): 
     1798        for r_i, r in enumerate(self.best_rule): 
     1799            if r and not rule_in_set(r, best_rules) and int(examples[r_i].getclass()) == int(r.classifier.default_value): 
    17701800                if hasattr(r.learner, "arg_example"): 
    17711801                    setattr(r, "best_example", r.learner.arg_example) 
     
    17741804                best_rules.append(r) 
    17751805        return best_rules 
    1776          
     1806 
    17771807    def __call__(self, rule, examples, weights, target_class): 
    17781808        """ if example has an argument, then the rule must be consistent with the argument. """ 
     
    17821812                e[self.prob_attribute] = 1.0 
    17831813                self.best_rule[ei] = rule 
    1784             elif rule(e) and rule.quality>e[self.prob_attribute]: 
    1785                 e[self.prob_attribute] = rule.quality+0.001 # 0.001 is added to avoid numerical errors 
    1786                 self.best_rule[ei]=rule 
    1787         return (examples,weights) 
     1814            elif rule(e) and rule.quality > e[self.prob_attribute]: 
     1815                e[self.prob_attribute] = rule.quality + 0.001 # 0.001 is added to avoid numerical errors 
     1816                self.best_rule[ei] = rule 
     1817        return (examples, weights) 
    17881818 
    17891819    def filter_covers_example(self, example, filter): 
     
    17911821        if filter(example): 
    17921822            try: 
    1793                 if example[self.argument_id].value and len(example[self.argument_id].value.positive_arguments)>0: # example has positive arguments 
     1823                if example[self.argument_id].value and len(example[self.argument_id].value.positive_arguments) > 0: # example has positive arguments 
    17941824                    # conditions should cover at least one of the positive arguments 
    17951825                    one_arg_covered = False 
    17961826                    for pA in example[self.argument_id].value.positive_arguments: 
    1797                         arg_covered = [self.condIn(c,filter_indices) for c in pA.filter.conditions] 
     1827                        arg_covered = [self.condIn(c, filter_indices) for c in pA.filter.conditions] 
    17981828                        one_arg_covered = one_arg_covered or len(arg_covered) == sum(arg_covered) #arg_covered 
    17991829                        if one_arg_covered: 
     
    18011831                    if not one_arg_covered: 
    18021832                        return False 
    1803                 if example[self.argument_id].value and len(example[self.argument_id].value.negative_arguments)>0: # example has negative arguments 
     1833                if example[self.argument_id].value and len(example[self.argument_id].value.negative_arguments) > 0: # example has negative arguments 
    18041834                    # condition should not cover neither of negative arguments 
    18051835                    for pN in example[self.argument_id].value.negative_arguments: 
    18061836                        arg_covered = [self.condIn(c, filter_indices) for c in pN.filter.conditions] 
    1807                         if len(arg_covered)==sum(arg_covered): 
     1837                        if len(arg_covered) == sum(arg_covered): 
    18081838                            return False 
    18091839            except: 
     
    18141844    def condIn(self, cond, filter_indices): # is condition in the filter? 
    18151845        condInd = RuleCoversArguments.conditionIndex(cond) 
    1816         if operator.or_(condInd,filter_indices[cond.position]) == filter_indices[cond.position]: 
     1846        if operator.or_(condInd, filter_indices[cond.position]) == filter_indices[cond.position]: 
    18171847            return True 
    1818         return False         
     1848        return False 
    18191849 
    18201850 
     
    18221852        p = 0.0 
    18231853        for ei, e in enumerate(examples): 
    1824             p += (e[self.prob_attribute] - self.apriori_prob)/(1.0-self.apriori_prob) 
    1825         return p/len(examples) 
     1854            p += (e[self.prob_attribute] - self.apriori_prob) / (1.0 - self.apriori_prob) 
     1855        return p / len(examples) 
    18261856 
    18271857 
     
    18291859 
    18301860@deprecated_keywords({"showDistribution": "show_distribution"}) 
    1831 def rule_to_string(rule, show_distribution = True): 
     1861def rule_to_string(rule, show_distribution=True): 
    18321862    """ 
    18331863    Write a string presentation of rule in human readable format. 
     
    18561886    conds = rule.filter.conditions 
    18571887    domain = rule.filter.domain 
    1858      
     1888 
    18591889    ret = "IF " 
    1860     if len(conds)==0: 
     1890    if len(conds) == 0: 
    18611891        ret = ret + "TRUE" 
    18621892 
    1863     for i,c in enumerate(conds): 
     1893    for i, c in enumerate(conds): 
    18641894        if i > 0: 
    18651895            ret += " AND " 
     
    18711901    if rule.classifier and type(rule.classifier) == Orange.classification.ConstantClassifier\ 
    18721902            and rule.classifier.default_val: 
    1873         ret = ret + " THEN "+domain.class_var.name+"="+\ 
     1903        ret = ret + " THEN " + domain.class_var.name + "=" + \ 
    18741904        str(rule.classifier.default_value) 
    18751905        if show_distribution: 
     
    18771907    elif rule.classifier and type(rule.classifier) == Orange.classification.ConstantClassifier\ 
    18781908            and type(domain.class_var) == Orange.core.EnumVariable: 
    1879         ret = ret + " THEN "+domain.class_var.name+"="+\ 
     1909        ret = ret + " THEN " + domain.class_var.name + "=" + \ 
    18801910        str(rule.class_distribution.modus()) 
    18811911        if show_distribution: 
    18821912            ret += str(rule.class_distribution) 
    1883     return ret         
     1913    return ret 
    18841914 
    18851915def supervisedClassCheck(instances): 
     
    18881918    if instances.domain.class_var.varType == Orange.core.VarTypes.Continuous: 
    18891919        raise Exception("CN2 requires a discrete class!") 
    1890      
    1891  
    1892 def rule_in_set(rule,rules): 
     1920 
     1921 
     1922def rule_in_set(rule, rules): 
    18931923    for r in rules: 
    1894         if rules_equal(rule,r): 
     1924        if rules_equal(rule, r): 
    18951925            return True 
    18961926    return False 
    18971927 
    1898 def rules_equal(rule1,rule2): 
    1899     if not len(rule1.filter.conditions)==len(rule2.filter.conditions): 
     1928def rules_equal(rule1, rule2): 
     1929    if not len(rule1.filter.conditions) == len(rule2.filter.conditions): 
    19001930        return False 
    19011931    for c1 in rule1.filter.conditions: 
    1902         found=False # find the same condition in the other rule 
     1932        found = False # find the same condition in the other rule 
    19031933        for c2 in rule2.filter.conditions: 
    19041934            try: 
     
    19111941                    if not c1.oper == c2.oper: continue # same operator? 
    19121942                    if not c1.ref == c2.ref: continue #same threshold? 
    1913                 found=True 
     1943                found = True 
    19141944                break 
    19151945            except: 
     
    19211951# Miscellaneous - utility functions 
    19221952def avg(l): 
    1923     if len(l)==0: 
     1953    if len(l) == 0: 
    19241954        return 0. 
    1925     return sum(l)/len(l) 
     1955    return sum(l) / len(l) 
    19261956 
    19271957def var(l): 
    1928     if len(l)<2: 
     1958    if len(l) < 2: 
    19291959        return 0. 
    19301960    av = avg(l) 
    1931     vars=[math.pow(li-av,2) for li in l] 
    1932     return sum(vars)/(len(l)-1) 
     1961    vars = [math.pow(li - av, 2) for li in l] 
     1962    return sum(vars) / (len(l) - 1) 
    19331963 
    19341964def median(l): 
    1935     if len(l)==0: 
    1936         return 0.     
     1965    if len(l) == 0: 
     1966        return 0. 
    19371967    l.sort() 
    19381968    le = len(l) 
    1939     if le%2 == 1: 
    1940         return l[(le-1)/2] 
     1969    if le % 2 == 1: 
     1970        return l[(le - 1) / 2] 
    19411971    else: 
    1942         return (l[le/2-1]+l[le/2])/2 
    1943  
    1944 def perc(l,p): 
     1972        return (l[le / 2 - 1] + l[le / 2]) / 2 
     1973 
     1974def perc(l, p): 
    19451975    l.sort() 
    1946     return l[int(math.floor(p*len(l)))] 
     1976    return l[int(math.floor(p * len(l)))] 
    19471977 
    19481978class EVDFitter: 
     
    19551985        # initialize random seed to make experiments repeatable 
    19561986        random.seed(self.randomseed) 
    1957          
    1958          
     1987 
     1988 
    19591989    def createRandomDataSet(self, data): 
    19601990        newData = Orange.core.ExampleTable(data) 
    19611991        # shuffle data 
    19621992        cl_num = newData.toNumpy("C") 
    1963         random.shuffle(cl_num[0][:,0]) 
    1964         clData = Orange.core.ExampleTable(Orange.core.Domain([newData.domain.classVar]),cl_num[0]) 
    1965         for d_i,d in enumerate(newData): 
     1993        random.shuffle(cl_num[0][:, 0]) 
     1994        clData = Orange.core.ExampleTable(Orange.core.Domain([newData.domain.classVar]), cl_num[0]) 
     1995        for d_i, d in enumerate(newData): 
    19661996            d[newData.domain.classVar] = clData[d_i][newData.domain.classVar] 
    19671997        return newData 
     
    19702000        l = Orange.core.EVDistList() 
    19712001        for el in evdList: 
    1972             l.append(Orange.core.EVDist(mu=el[0],beta=el[1],percentiles=el[2])) 
     2002            l.append(Orange.core.EVDist(mu=el[0], beta=el[1], percentiles=el[2])) 
    19732003        return l 
    19742004 
    19752005 
    19762006    # estimated fisher tippett parameters for a set of values given in vals list (+ deciles) 
    1977     def compParameters(self, vals, oldMi, oldBeta, oldPercs, fixedBeta=False):                     
     2007    def compParameters(self, vals, oldMi, oldBeta, oldPercs, fixedBeta=False): 
    19782008        # compute percentiles 
    19792009        vals.sort() 
    19802010        N = len(vals) 
    1981         percs = [avg(vals[int(float(N)*i/10):int(float(N)*(i+1)/10)]) for i in range(10)] 
    1982         if N<10: 
     2011        percs = [avg(vals[int(float(N) * i / 10):int(float(N) * (i + 1) / 10)]) for i in range(10)] 
     2012        if N < 10: 
    19832013            return oldMi, oldBeta, percs 
    19842014        if not fixedBeta: 
    1985             beta = min(2.0, math.sqrt(6*var(vals)/math.pow(math.pi,2)))#min(2.0, max(oldBeta, math.sqrt(6*var(vals)/math.pow(math.pi,2)))) 
     2015            beta = min(2.0, math.sqrt(6 * var(vals) / math.pow(math.pi, 2)))#min(2.0, max(oldBeta, math.sqrt(6*var(vals)/math.pow(math.pi,2)))) 
    19862016        else: 
    19872017            beta = oldBeta 
    1988         mi = max(oldMi,percs[-1]+beta*math.log(-math.log(0.95))) 
    1989         mi = percs[-1]+beta*math.log(-math.log(0.95)) 
    1990         return max(oldMi, numpy.average(vals)-beta*0.5772156649), beta, None 
    1991      
     2018        mi = max(oldMi, percs[-1] + beta * math.log(-math.log(0.95))) 
     2019        mi = percs[-1] + beta * math.log(-math.log(0.95)) 
     2020        return max(oldMi, numpy.average(vals) - beta * 0.5772156649), beta, None 
     2021 
    19922022    def prepare_learner(self): 
    19932023        self.oldStopper = self.learner.ruleFinder.ruleStoppingValidator 
     
    20022032        self.learner.ruleFinder.ruleStoppingValidator.max_rule_complexity = 0 
    20032033        self.learner.ruleFinder.refiner = Orange.core.RuleBeamRefiner_Selector() 
    2004         self.learner.ruleFinder.ruleFilter = Orange.core.RuleBeamFilter_Width(width = 5) 
     2034        self.learner.ruleFinder.ruleFilter = Orange.core.RuleBeamFilter_Width(width=5) 
    20052035 
    20062036 
     
    20182048 
    20192049        # loop through N (sampling repetitions) 
    2020         extremeDists=[(0, 1, [])] 
     2050        extremeDists = [(0, 1, [])] 
    20212051        self.learner.ruleFinder.ruleStoppingValidator.max_rule_complexity = self.oldStopper.max_rule_complexity 
    2022         maxVals = [[] for l in range(self.oldStopper.max_rule_complexity+1)] 
     2052        maxVals = [[] for l in range(self.oldStopper.max_rule_complexity + 1)] 
    20232053        for d_i in range(self.n): 
    20242054            if not progress: 
     
    20262056                    print d_i, 
    20272057            else: 
    2028                 progress(float(d_i)/self.n, None)                 
     2058                progress(float(d_i) / self.n, None) 
    20292059            # create data set (remove and randomize) 
    20302060            a = time.time() 
     
    20332063            self.learner.ruleFinder.evaluator.rules = RuleList() 
    20342064            a = time.time() 
    2035             for l in range(self.oldStopper.max_rule_complexity+2): 
     2065            for l in range(self.oldStopper.max_rule_complexity + 2): 
    20362066               self.learner.ruleFinder.evaluator.rules.append(None) 
    20372067            a = time.time() 
    20382068            # Next, learn a rule 
    2039             self.learner.ruleFinder(tempData,weightID,target_class, RuleList()) 
     2069            self.learner.ruleFinder(tempData, weightID, target_class, RuleList()) 
    20402070            a = time.time() 
    2041             for l in range(self.oldStopper.max_rule_complexity+1): 
     2071            for l in range(self.oldStopper.max_rule_complexity + 1): 
    20422072                if self.learner.ruleFinder.evaluator.rules[l]: 
    20432073                    maxVals[l].append(self.learner.ruleFinder.evaluator.rules[l].quality) 
     
    20582088        for l in range(self.oldStopper.max_rule_complexity): 
    20592089            for i in range(len(maxVals[l])): 
    2060                 if maxVals[l+1][i] < maxVals[l][i]: 
    2061                     maxVals[l+1][i] = maxVals[l][i] 
     2090                if maxVals[l + 1][i] < maxVals[l][i]: 
     2091                    maxVals[l + 1][i] = maxVals[l][i] 
    20622092##        print 
    20632093##        for mi, m in enumerate(maxVals): 
    20642094##            print "mi=",mi,m 
    20652095 
    2066         mu, beta, perc = 1.0, 2.0, [0.0]*10 
    2067         for mi,m in enumerate(maxVals): 
     2096        mu, beta, perc = 1.0, 2.0, [0.0] * 10 
     2097        for mi, m in enumerate(maxVals): 
    20682098##            if mi == 0: 
    20692099##                mu, beta, perc = self.compParameters(m, mu, beta, perc) 
     
    20712101            mu, beta, perc = self.compParameters(m, mu, beta, perc, fixedBeta=True) 
    20722102            extremeDists.append((mu, beta, perc)) 
    2073             extremeDists.extend([(0,1,[])]*(mi)) 
     2103            extremeDists.extend([(0, 1, [])] * (mi)) 
    20742104            if self.learner.debug: 
    20752105                print mi, mu, beta, perc 
     
    20772107        self.restore_learner() 
    20782108        return self.createEVDistList(extremeDists) 
    2079          
     2109 
    20802110class ABBeamFilter(Orange.core.RuleBeamFilter): 
    20812111    """ 
     
    20842114        - leaves first N rules that have only of arguments in condition part 
    20852115    """ 
    2086     def __init__(self,width=5): 
    2087         self.width=width 
    2088         self.pArgs=None 
    2089  
    2090     def __call__(self,rulesStar,examples,weight_id): 
    2091         newStar=Orange.core.RuleList() 
    2092         rulesStar.sort(lambda x,y: -cmp(x.quality,y.quality)) 
    2093         argsNum=0 
    2094         for r_i,r in enumerate(rulesStar): 
    2095             if r_i<self.width: # either is one of best "width" rules 
     2116    def __init__(self, width=5): 
     2117        self.width = width 
     2118        self.pArgs = None 
     2119 
     2120    def __call__(self, rulesStar, examples, weight_id): 
     2121        newStar = Orange.core.RuleList() 
     2122        rulesStar.sort(lambda x, y:-cmp(x.quality, y.quality)) 
     2123        argsNum = 0 
     2124        for r_i, r in enumerate(rulesStar): 
     2125            if r_i < self.width: # either is one of best "width" rules 
    20962126                newStar.append(r) 
    20972127            elif self.onlyPositives(r): 
    2098                 if argsNum<self.width: 
     2128                if argsNum < self.width: 
    20992129                    newStar.append(r) 
    2100                     argsNum+=1 
    2101         return newStar                 
    2102  
    2103     def setArguments(self,domain,positive_arguments): 
     2130                    argsNum += 1 
     2131        return newStar 
     2132 
     2133    def setArguments(self, domain, positive_arguments): 
    21042134        self.pArgs = positive_arguments 
    21052135        self.domain = domain 
    2106         self.argTab = [0]*len(self.domain.attributes) 
     2136        self.argTab = [0] * len(self.domain.attributes) 
    21072137        for arg in self.pArgs: 
    21082138            for cond in arg.filter.conditions: 
    2109                 self.argTab[cond.position]=1 
    2110          
    2111     def onlyPositives(self,rule): 
     2139                self.argTab[cond.position] = 1 
     2140 
     2141    def onlyPositives(self, rule): 
    21122142        if not self.pArgs: 
    21132143            return False 
    21142144 
    2115         ruleTab=[0]*len(self.domain.attributes) 
     2145        ruleTab = [0] * len(self.domain.attributes) 
    21162146        for cond in rule.filter.conditions: 
    2117             ruleTab[cond.position]=1 
    2118         return map(operator.or_,ruleTab,self.argTab)==self.argTab 
     2147            ruleTab[cond.position] = 1 
     2148        return map(operator.or_, ruleTab, self.argTab) == self.argTab 
    21192149 
    21202150 
     
    21272157        self.indices = [] 
    21282158        for a in self.arguments: 
    2129             indNA = getattr(a.filter,"indices",None) 
     2159            indNA = getattr(a.filter, "indices", None) 
    21302160            if not indNA: 
    21312161                a.filter.setattr("indices", RuleCoversArguments.filterIndices(a.filter)) 
     
    21352165        if not self.indices: 
    21362166            return False 
    2137         if not getattr(rule.filter,"indices",None): 
     2167        if not getattr(rule.filter, "indices", None): 
    21382168            rule.filter.indices = RuleCoversArguments.filterIndices(rule.filter) 
    21392169        for index in self.indices: 
    2140             if map(operator.or_,rule.filter.indices,index) == rule.filter.indices: 
     2170            if map(operator.or_, rule.filter.indices, index) == rule.filter.indices: 
    21412171                return True 
    21422172        return False 
     
    21452175        if not filter.domain: 
    21462176            return [] 
    2147         ind = [0]*len(filter.domain.attributes) 
     2177        ind = [0] * len(filter.domain.attributes) 
    21482178        for c in filter.conditions: 
    2149             ind[c.position]=operator.or_(ind[c.position], 
     2179            ind[c.position] = operator.or_(ind[c.position], 
    21502180                                         RuleCoversArguments.conditionIndex(c)) 
    21512181        return ind 
     
    21642194        else: 
    21652195            return 1 # 0001 
    2166     conditionIndex = staticmethod(conditionIndex)         
     2196    conditionIndex = staticmethod(conditionIndex) 
    21672197 
    21682198    def oneSelectorToCover(ruleIndices, argIndices): 
     
    21712201            if not argIndices[r_i]: 
    21722202                continue 
    2173             if at>-1 and not ind == argIndices[r_i]: # need two changes 
    2174                 return (-1,0) 
     2203            if at > -1 and not ind == argIndices[r_i]: # need two changes 
     2204                return (-1, 0) 
    21752205            if not ind == argIndices[r_i]: 
    2176                 if argIndices[r_i] in [1,3,5]: 
    2177                     at,type=r_i,argIndices[r_i] 
    2178                 if argIndices[r_i]==6: 
    2179                     if ind==3: 
    2180                         at,type=r_i,5 
    2181                     if ind==5: 
    2182                         at,type=r_i,3 
    2183         return at,type 
     2206                if argIndices[r_i] in [1, 3, 5]: 
     2207                    at, type = r_i, argIndices[r_i] 
     2208                if argIndices[r_i] == 6: 
     2209                    if ind == 3: 
     2210                        at, type = r_i, 5 
     2211                    if ind == 5: 
     2212                        at, type = r_i, 3 
     2213        return at, type 
    21842214    oneSelectorToCover = staticmethod(oneSelectorToCover) 
    21852215 
     
    21902220       - refined rules are not consistent with any of negative arguments. 
    21912221    """ 
    2192     def __init__(self, example=None, not_allowed_selectors=[], argument_id = None, 
    2193                  discretizer = Orange.core.EntropyDiscretization(forceAttribute=True)): 
     2222    def __init__(self, example=None, not_allowed_selectors=[], argument_id=None, 
     2223                 discretizer=Orange.core.EntropyDiscretization(forceAttribute=True)): 
    21942224        # required values - needed values of attributes 
    21952225        self.example = example 
     
    21972227        self.not_allowed_selectors = not_allowed_selectors 
    21982228        self.discretizer = discretizer 
    2199          
    2200     def __call__(self, oldRule, data, weight_id, target_class=-1): 
     2229 
     2230    def __call__(self, oldRule, data, weight_id, target_class= -1): 
    22012231        inNotAllowedSelectors = RuleCoversArguments(self.not_allowed_selectors) 
    22022232        new_rules = Orange.core.RuleList() 
    22032233 
    22042234        # get positive indices (selectors already in the rule) 
    2205         indices = getattr(oldRule.filter,"indices",None) 
     2235        indices = getattr(oldRule.filter, "indices", None) 
    22062236        if not indices: 
    22072237            indices = RuleCoversArguments.filterIndices(oldRule.filter) 
    2208             oldRule.filter.setattr("indices",indices) 
     2238            oldRule.filter.setattr("indices", indices) 
    22092239 
    22102240        # get negative indices (selectors that should not be in the rule) 
    2211         negative_indices = [0]*len(data.domain.attributes) 
     2241        negative_indices = [0] * len(data.domain.attributes) 
    22122242        for nA in self.not_allowed_selectors: 
    22132243            #print indices, nA.filter.indices 
    2214             at_i,type_na = RuleCoversArguments.oneSelectorToCover(indices, nA.filter.indices) 
    2215             if at_i>-1: 
    2216                 negative_indices[at_i] = operator.or_(negative_indices[at_i],type_na) 
     2244            at_i, type_na = RuleCoversArguments.oneSelectorToCover(indices, nA.filter.indices) 
     2245            if at_i > -1: 
     2246                negative_indices[at_i] = operator.or_(negative_indices[at_i], type_na) 
    22172247 
    22182248        #iterate through indices = attributes  
    2219         for i,ind in enumerate(indices): 
     2249        for i, ind in enumerate(indices): 
    22202250            if not self.example[i] or self.example[i].isSpecial(): 
    22212251                continue 
    2222             if ind == 1:  
     2252            if ind == 1: 
    22232253                continue 
    2224             if data.domain[i].varType == Orange.core.VarTypes.Discrete and not negative_indices[i]==1: # DISCRETE attribute 
     2254            if data.domain[i].varType == Orange.core.VarTypes.Discrete and not negative_indices[i] == 1: # DISCRETE attribute 
    22252255                if self.example: 
    22262256                    values = [self.example[i]] 
     
    22292259                for v in values: 
    22302260                    tempRule = oldRule.clone() 
    2231                     tempRule.filter.conditions.append(Orange.core.ValueFilter_discrete(position = i, 
    2232                                                                                   values = [Orange.core.Value(data.domain[i],v)], 
     2261                    tempRule.filter.conditions.append(Orange.core.ValueFilter_discrete(position=i, 
     2262                                                                                  values=[Orange.core.Value(data.domain[i], v)], 
    22332263                                                                                  acceptSpecial=0)) 
    22342264                    tempRule.complexity += 1 
    22352265                    tempRule.filter.indices[i] = 1 # 1 stands for discrete attribute (see RuleCoversArguments.conditionIndex) 
    22362266                    tempRule.filterAndStore(oldRule.examples, oldRule.weightID, target_class) 
    2237                     if len(tempRule.examples)<len(oldRule.examples): 
     2267                    if len(tempRule.examples) < len(oldRule.examples): 
    22382268                        new_rules.append(tempRule) 
    2239             elif data.domain[i].varType == Orange.core.VarTypes.Continuous and not negative_indices[i]==7: # CONTINUOUS attribute 
     2269            elif data.domain[i].varType == Orange.core.VarTypes.Continuous and not negative_indices[i] == 7: # CONTINUOUS attribute 
    22402270                try: 
    22412271                    at = data.domain[i] 
    2242                     at_d = self.discretizer(at,oldRule.examples) 
     2272                    at_d = self.discretizer(at, oldRule.examples) 
    22432273                except: 
    22442274                    continue # discretization failed ! 
    22452275                # If discretization makes sense? then: 
    2246                 if len(at_d.values)>1: 
     2276                if len(at_d.values) > 1: 
    22472277                    for p in at_d.getValueFrom.transformer.points: 
    22482278                        #LESS 
    2249                         if not negative_indices[i]==3: 
    2250                             tempRule = self.getTempRule(oldRule,i,Orange.core.ValueFilter_continuous.LessEqual,p,target_class,3) 
    2251                             if len(tempRule.examples)<len(oldRule.examples) and self.example[i]<=p:# and not inNotAllowedSelectors(tempRule): 
     2279                        if not negative_indices[i] == 3: 
     2280                            tempRule = self.getTempRule(oldRule, i, Orange.core.ValueFilter_continuous.LessEqual, p, target_class, 3) 
     2281                            if len(tempRule.examples) < len(oldRule.examples) and self.example[i] <= p:# and not inNotAllowedSelectors(tempRule): 
    22522282                                new_rules.append(tempRule) 
    22532283                        #GREATER 
    2254                         if not negative_indices[i]==5: 
    2255                             tempRule = self.getTempRule(oldRule,i,Orange.core.ValueFilter_continuous.Greater,p,target_class,5) 
    2256                             if len(tempRule.examples)<len(oldRule.examples) and self.example[i]>p:# and not inNotAllowedSelectors(tempRule): 
     2284                        if not negative_indices[i] == 5: 
     2285                            tempRule = self.getTempRule(oldRule, i, Orange.core.ValueFilter_continuous.Greater, p, target_class, 5) 
     2286                            if len(tempRule.examples) < len(oldRule.examples) and self.example[i] > p:# and not inNotAllowedSelectors(tempRule): 
    22572287                                new_rules.append(tempRule) 
    22582288        for r in new_rules: 
     
    22612291        return new_rules 
    22622292 
    2263     def getTempRule(self,oldRule,pos,oper,ref,target_class,atIndex): 
     2293    def getTempRule(self, oldRule, pos, oper, ref, target_class, atIndex): 
    22642294        tempRule = oldRule.clone() 
    22652295 
     
    22692299                                                                        acceptSpecial=0)) 
    22702300        tempRule.complexity += 1 
    2271         tempRule.filter.indices[pos] = operator.or_(tempRule.filter.indices[pos],atIndex) # from RuleCoversArguments.conditionIndex 
    2272         tempRule.filterAndStore(oldRule.examples,tempRule.weightID,target_class) 
     2301        tempRule.filter.indices[pos] = operator.or_(tempRule.filter.indices[pos], atIndex) # from RuleCoversArguments.conditionIndex 
     2302        tempRule.filterAndStore(oldRule.examples, tempRule.weightID, target_class) 
    22732303        return tempRule 
    22742304 
     
    22762306        tempRule = oldRule.clone() 
    22772307        tempRule.filter.conditions[ci] = condition 
    2278         tempRule.filter.conditions[ci].setattr("specialized",1) 
    2279         tempRule.filterAndStore(oldRule.examples,oldRule.weightID,target_class) 
     2308        tempRule.filter.conditions[ci].setattr("specialized", 1) 
     2309        tempRule.filterAndStore(oldRule.examples, oldRule.weightID, target_class) 
    22802310        return tempRule 
    22812311 
     
    22872317class ArgFilter(Orange.core.Filter): 
    22882318    """ This class implements AB-covering principle. """ 
    2289     def __init__(self, argument_id=None, filter = Orange.core.Filter_values(), arg_example = None): 
     2319    def __init__(self, argument_id=None, filter=Orange.core.Filter_values(), arg_example=None): 
    22902320        self.filter = filter 
    2291         self.indices = getattr(filter,"indices",[]) 
    2292         if not self.indices and len(filter.conditions)>0: 
     2321        self.indices = getattr(filter, "indices", []) 
     2322        if not self.indices and len(filter.conditions) > 0: 
    22932323            self.indices = RuleCoversArguments.filterIndices(filter) 
    22942324        self.argument_id = argument_id 
     
    22962326        self.conditions = filter.conditions 
    22972327        self.arg_example = arg_example 
    2298          
    2299     def condIn(self,cond): # is condition in the filter? 
     2328 
     2329    def condIn(self, cond): # is condition in the filter? 
    23002330        condInd = ruleCoversArguments.conditionIndex(cond) 
    2301         if operator.or_(condInd,self.indices[cond.position]) == self.indices[cond.position]: 
     2331        if operator.or_(condInd, self.indices[cond.position]) == self.indices[cond.position]: 
    23022332            return True 
    23032333        return False 
    2304      
    2305     def __call__(self,example): 
     2334 
     2335    def __call__(self, example): 
    23062336##        print "in", self.filter(example)#, self.filter.conditions[0](example) 
    23072337##        print self.filter.conditions[1].values 
     
    23102340        elif self.filter(example): 
    23112341            try: 
    2312                 if example[self.argument_id].value and len(example[self.argument_id].value.positiveArguments)>0: # example has positive arguments 
     2342                if example[self.argument_id].value and len(example[self.argument_id].value.positiveArguments) > 0: # example has positive arguments 
    23132343                    # conditions should cover at least one of the positive arguments 
    23142344                    oneArgCovered = False 
     
    23202350                    if not oneArgCovered: 
    23212351                        return False 
    2322                 if example[self.argument_id].value and len(example[self.argument_id].value.negativeArguments)>0: # example has negative arguments 
     2352                if example[self.argument_id].value and len(example[self.argument_id].value.negativeArguments) > 0: # example has negative arguments 
    23232353                    # condition should not cover neither of negative arguments 
    23242354                    for pN in example[self.argument_id].value.negativeArguments: 
    23252355                        argCovered = [self.condIn(c) for c in pN.filter.conditions] 
    2326                         if len(argCovered)==sum(argCovered): 
     2356                        if len(argCovered) == sum(argCovered): 
    23272357                            return False 
    23282358            except: 
     
    23322362            return False 
    23332363 
    2334     def __setattr__(self,name,obj): 
    2335         self.__dict__[name]=obj 
    2336         self.filter.setattr(name,obj) 
     2364    def __setattr__(self, name, obj): 
     2365        self.__dict__[name] = obj 
     2366        self.filter.setattr(name, obj) 
    23372367 
    23382368    def deep_copy(self): 
     
    23602390        self.allowed_selectors = allowed_selectors 
    23612391 
    2362     def __call__(self, oldRule, data, weight_id, target_class=-1): 
     2392    def __call__(self, oldRule, data, weight_id, target_class= -1): 
    23632393        if len(oldRule.filter.conditions) >= len(self.allowed_selectors): 
    23642394            return Orange.core.RuleList() 
     
    23702400                tempRule.filter.conditions.append(c) 
    23712401                tempRule.filterAndStore(oldRule.examples, oldRule.weightID, target_class) 
    2372                 if len(tempRule.examples)<len(oldRule.examples): 
     2402                if len(tempRule.examples) < len(oldRule.examples): 
    23732403                    new_rules.append(tempRule) 
    23742404            # unspecified condition 
     
    23892419                    if tempRule(self.example): 
    23902420                        tempRule.filterAndStore(oldRule.examples, oldRule.weightID, target_class) 
    2391                         if len(tempRule.examples)<len(oldRule.examples): 
     2421                        if len(tempRule.examples) < len(oldRule.examples): 
    23922422                            new_rules.append(tempRule) 
    23932423##        print " NEW RULES " 
     
    24012431 
    24022432class CrossValidation: 
    2403     def __init__(self, folds=5, random_generator = 150): 
     2433    def __init__(self, folds=5, random_generator=150): 
    24042434        self.folds = folds 
    24052435        self.random_generator = random_generator 
    24062436 
    24072437    def __call__(self, learner, examples, weight): 
    2408         res = orngTest.crossValidation([learner], (examples, weight), folds = self.folds, random_generator = self.random_generator) 
     2438        res = orngTest.crossValidation([learner], (examples, weight), folds=self.folds, random_generator=self.random_generator) 
    24092439        return self.get_prob_from_res(res, examples) 
    24102440 
     
    24232453    PILAR (Probabilistic improvement of learning algorithms with rules). 
    24242454    """ 
    2425     def __init__(self, alternative_learner = None, min_cl_sig = 0.5, min_beta = 0.0, set_prefix_rules = False, optimize_betas = True): 
     2455    def __init__(self, alternative_learner=None, min_cl_sig=0.5, min_beta=0.0, set_prefix_rules=False, optimize_betas=True): 
    24262456        self.alternative_learner = alternative_learner 
    24272457        self.min_cl_sig = min_cl_sig 
     
    24352465        if self.alternative_learner: 
    24362466            prob_dist = self.selected_evaluation(self.alternative_learner, examples, weight) 
    2437             classifier = self.alternative_learner(examples,weight) 
     2467            classifier = self.alternative_learner(examples, weight) 
    24382468##            prob_dist = Orange.core.DistributionList() 
    24392469##            for e in examples: 
     
    24442474 
    24452475##        print "result" 
    2446         for ri,r in enumerate(cl.rules): 
    2447             cl.rules[ri].setattr("beta",cl.ruleBetas[ri]) 
     2476        for ri, r in enumerate(cl.rules): 
     2477            cl.rules[ri].setattr("beta", cl.ruleBetas[ri]) 
    24482478##            if cl.ruleBetas[ri] > 0: 
    24492479##                print Orange.classification.rules.rule_to_string(r), r.quality, cl.ruleBetas[ri] 
     
    24572487        for cl in examples.domain.class_var: 
    24582488            tmpRle = Orange.core.Rule() 
    2459             tmpRle.filter = Orange.core.Filter_values(domain = examples.domain) 
     2489            tmpRle.filter = Orange.core.Filter_values(domain=examples.domain) 
    24602490            tmpRle.parentRule = None 
    2461             tmpRle.filterAndStore(examples,weight,int(cl)) 
    2462             tmpRle.quality = tmpRle.class_distribution[int(cl)]/tmpRle.class_distribution.abs 
     2491            tmpRle.filterAndStore(examples, weight, int(cl)) 
     2492            tmpRle.quality = tmpRle.class_distribution[int(cl)] / tmpRle.class_distribution.abs 
    24632493            rules.append(tmpRle) 
    24642494        return rules 
    2465          
     2495 
    24662496    def sort_rules(self, rules): 
    24672497        new_rules = Orange.core.RuleList() 
     
    24832513                    foundRule = True 
    24842514                    continue 
    2485                 if len(r.filter.conditions) ==  len(bestRule.filter.conditions) and r.beta > bestRule.beta: 
     2515                if len(r.filter.conditions) == len(bestRule.filter.conditions) and r.beta > bestRule.beta: 
    24862516                    bestRule = r 
    24872517                    foundRule = True 
     
    24992529    normalizes probabilities. 
    25002530    """ 
    2501     def __init__(self, rules, examples, weight_id = 0, **argkw): 
     2531    def __init__(self, rules, examples, weight_id=0, **argkw): 
    25022532        self.rules = rules 
    25032533        self.examples = examples 
    2504         self.apriori = Orange.core.Distribution(examples.domain.class_var,examples,weight_id) 
    2505         self.apriori_prob = [a/self.apriori.abs for a in self.apriori] 
     2534        self.apriori = Orange.core.Distribution(examples.domain.class_var, examples, weight_id) 
     2535        self.apriori_prob = [a / self.apriori.abs for a in self.apriori] 
    25062536        self.weight_id = weight_id 
    25072537        self.__dict__.update(argkw) 
     
    25092539 
    25102540    @deprecated_keywords({"retRules": "ret_rules"}) 
    2511     def __call__(self, example, result_type=Orange.classification.Classifier.GetValue, ret_rules = False): 
    2512         example = Orange.core.Example(self.examples.domain,example) 
     2541    def __call__(self, example, result_type=Orange.classification.Classifier.GetValue, ret_rules=False): 
     2542        example = Orange.core.Example(self.examples.domain, example) 
    25132543        tempDist = Orange.core.Distribution(example.domain.class_var) 
    2514         best_rules = [None]*len(example.domain.class_var.values) 
     2544        best_rules = [None] * len(example.domain.class_var.values) 
    25152545 
    25162546        for r in self.rules: 
    25172547            if r(example) and not self.default_class_index == int(r.classifier.default_val) and \ 
    2518                (not best_rules[int(r.classifier.default_val)] or r.quality>tempDist[r.classifier.default_val]): 
     2548               (not best_rules[int(r.classifier.default_val)] or r.quality > tempDist[r.classifier.default_val]): 
    25192549                tempDist[r.classifier.default_val] = r.quality 
    25202550                best_rules[int(r.classifier.default_val)] = r 
    25212551        for b in best_rules: 
    25222552            if b: 
    2523                 used = getattr(b,"used",0.0) 
    2524                 b.setattr("used",used+1) 
     2553                used = getattr(b, "used", 0.0) 
     2554                b.setattr("used", used + 1) 
    25252555        nonCovPriorSum = sum([tempDist[i] == 0. and self.apriori_prob[i] or 0. for i in range(len(self.apriori_prob))]) 
    25262556        if tempDist.abs < 1.: 
    25272557            residue = 1. - tempDist.abs 
    2528             for a_i,a in enumerate(self.apriori_prob): 
     2558            for a_i, a in enumerate(self.apriori_prob): 
    25292559                if tempDist[a_i] == 0.: 
    2530                     tempDist[a_i]=self.apriori_prob[a_i]*residue/nonCovPriorSum 
     2560                    tempDist[a_i] = self.apriori_prob[a_i] * residue / nonCovPriorSum 
    25312561            final_dist = tempDist #Orange.core.Distribution(example.domain.class_var) 
    25322562        else: 
     
    25362566                if r: 
    25372567                    tmp_examples = r.filter(tmp_examples) 
    2538             tmpDist = Orange.core.Distribution(tmp_examples.domain.class_var,tmp_examples,self.weight_id) 
     2568            tmpDist = Orange.core.Distribution(tmp_examples.domain.class_var, tmp_examples, self.weight_id) 
    25392569            tmpDist.normalize() 
    2540             probs = [0.]*len(self.examples.domain.class_var.values) 
     2570            probs = [0.] * len(self.examples.domain.class_var.values) 
    25412571            for i in range(len(self.examples.domain.class_var.values)): 
    2542                 probs[i] = tmpDist[i]+tempDist[i]*2 
     2572                probs[i] = tmpDist[i] + tempDist[i] * 2 
    25432573            final_dist = Orange.core.Distribution(self.examples.domain.class_var) 
    2544             for cl_i,cl in enumerate(self.examples.domain.class_var): 
     2574            for cl_i, cl in enumerate(self.examples.domain.class_var): 
    25452575                final_dist[cl] = probs[cl_i] 
    25462576            final_dist.normalize() 
    2547                  
     2577 
    25482578        if ret_rules: # Do you want to return rules with classification? 
    25492579            if result_type == Orange.classification.Classifier.GetValue: 
    2550               return (final_dist.modus(),best_rules) 
     2580              return (final_dist.modus(), best_rules) 
    25512581            if result_type == Orange.core.GetProbabilities: 
    25522582              return (final_dist, best_rules) 
    2553             return (final_dist.modus(),final_dist, best_rules) 
     2583            return (final_dist.modus(), final_dist, best_rules) 
    25542584        if result_type == Orange.classification.Classifier.GetValue: 
    25552585          return final_dist.modus() 
    25562586        if result_type == Orange.core.GetProbabilities: 
    25572587          return final_dist 
    2558         return (final_dist.modus(),final_dist) 
    2559      
     2588        return (final_dist.modus(), final_dist) 
     2589 
    25602590RuleClassifier_bestRule = deprecated_members({"defaultClassIndex": "default_class_index"})(RuleClassifier_bestRule) 
Note: See TracChangeset for help on using the changeset viewer.