Changeset 8233:7ed1b1190a75 in orange


Ignore:
Timestamp:
08/19/11 11:06:12 (3 years ago)
Author:
martin <martin@…>
Branch:
default
Convert:
29e98a17eba9d767201b58b301fc03c6d53dd202
Message:
 
File:
1 edited

Legend:

Unmodified
Added
Removed
  • orange/Orange/classification/rules.py

    r8042 r8233  
    10671067       (default) 
    10681068    :type analyse_argument: int 
     1069    :param debug: sets debug mode - prints some info during execution; False (default) 
     1070    :type debug: boolean 
    10691071     
    10701072    The following evaluator related arguments are supported: 
     
    11121114    :param alternative_learner: use rule-learner as a correction method for 
    11131115       other machine learning methods (default None). 
     1116 
    11141117    """ 
    11151118     
     
    11171120                 rule_sig=1.0, att_sig=1.0, postpruning=None, min_quality=0., min_coverage=1, min_improved=1, min_improved_perc=0.0, 
    11181121                 learn_for_class = None, learn_one_rule = False, evd=None, evd_arguments=None, prune_arguments=False, analyse_argument=-1, 
    1119                  alternative_learner = None, min_cl_sig = 0.5, min_beta = 0.0, set_prefix_rules = False, add_sub_rules = False, 
     1122                 alternative_learner = None, min_cl_sig = 0.5, min_beta = 0.0, set_prefix_rules = False, add_sub_rules = False, debug=False, 
    11201123                 **kwds): 
    11211124         
     
    11591162        self.add_sub_rules = add_sub_rules 
    11601163        self.classifier = PILAR(alternative_learner = alternative_learner, min_cl_sig = min_cl_sig, min_beta = min_beta, set_prefix_rules = set_prefix_rules) 
     1164        self.debug = debug 
    11611165        # arbitrary parameters 
    11621166        self.__dict__.update(kwds) 
     
    11871191 
    11881192            # rules for this class only 
    1189             rules, arg_rules = RuleList(), RuleList() 
     1193            rules = RuleList() 
    11901194 
    11911195            # create dichotomous class 
     
    12081212            aes = self.sort_arguments(aes, dich_data) 
    12091213            while aes: 
    1210                 if self.analyse_argument > -1 and not dich_data[self.analyse_argument] == aes[0]: 
     1214                if self.analyse_argument > -1 and \ 
     1215                   (isinstance(self.analyse_argument, Orange.core.Example) and not Orange.core.Example(dich_data.domain, self.analyse_argument) == aes[0] or \ 
     1216                    isinstance(self.analyse_argument, int) and not dich_data[self.analyse_argument] == aes[0]): 
    12111217                    aes = aes[1:] 
    12121218                    continue 
    12131219                ae = aes[0] 
    12141220                rule = self.learn_argumented_rule(ae, dich_data, weight_id) # target class is always first class (0) 
    1215                 if not progress: 
    1216                     print "learned rule", Orange.classification.rules.rule_to_string(rule) 
     1221                if debug and rule: 
     1222                    print "learned arg rule", Orange.classification.rules.rule_to_string(rule) 
     1223                elif debug: 
     1224                    print "no rule came out of ", ae 
    12171225                if rule: 
    1218                     arg_rules.append(rule) 
     1226                    rules.append(rule) 
    12191227                    aes = filter(lambda x: not rule(x), aes) 
    12201228                else: 
    12211229                    aes = aes[1:] 
     1230                aes = aes[1:] 
     1231 
    12221232            if not progress: 
    12231233                print " arguments finished ... "                     
    12241234                    
    12251235            # remove all examples covered by rules 
    1226 ##            for rule in rules: 
    1227 ##                dich_data = self.remove_covered_examples(rule, dich_data, weight_id) 
    1228 ##            if progress: 
    1229 ##                progress(self.remaining_probability(dich_data),None) 
     1236            for rule in rules: 
     1237                dich_data = self.remove_covered_examples(rule, dich_data, weight_id) 
     1238            if progress: 
     1239                progress(self.remaining_probability(dich_data),None) 
    12301240 
    12311241            # learn normal rules on remaining examples 
     
    12371247                    if not rule: 
    12381248                        break 
    1239                     if not progress: 
     1249                    if self.debug: 
    12401250                        print "rule learned: ", Orange.classification.rules.rule_to_string(rule), rule.quality 
    12411251                    dich_data = self.remove_covered_examples(rule, dich_data, weight_id) 
     
    12461256                        break 
    12471257 
    1248             for r in arg_rules: 
    1249                 dich_data = self.remove_covered_examples(r, dich_data, weight_id) 
    1250                 rules.append(r) 
    1251  
    12521258            # prune unnecessary rules 
    12531259            rules = self.prune_unnecessary_rules(rules, dich_data, weight_id) 
     
    12831289        self.rule_finder.evaluator.returnBestFuture = True 
    12841290        self.rule_finder(examples,weight_id,0,positive_args) 
    1285 ##        self.rule_finder.evaluator.bestRule.quality = 0.8 
    12861291         
    12871292        # return best rule 
     
    13811386 
    13821387    def change_domain(self, rule, cl, examples, weight_id): 
    1383         rule.examples = rule.examples.select(examples.domain) 
    1384         rule.class_distribution = Orange.statistics.distribution.Distribution( 
    1385                      rule.examples.domain.class_var,rule.examples,weight_id) # adapt distribution 
    1386         rule.classifier = Orange.classification.ConstantClassifier(cl) # adapt classifier 
    13871388        rule.filter = Orange.core.Filter_values(domain = examples.domain, 
    13881389                                        conditions = rule.filter.conditions) 
     1390        rule.filterAndStore(examples, weightID, cl)         
    13891391        if hasattr(rule, "learner") and hasattr(rule.learner, "arg_example"): 
    1390             rule.learner.arg_example = Orange.data.Instance( 
    1391                           examples.domain, rule.learner.arg_example) 
     1392            rule.learner.arg_example = Orange.data.Instance(examples.domain, rule.learner.arg_example) 
    13921393        return rule 
    13931394 
     
    14191420                    tmpRule.quality = self.rule_finder.evaluator(tmpRule,examples,weight_id,r.classifier.default_val,apriori) 
    14201421                    self.rule_finder.evaluator.returnExpectedProb = oldREP 
     1422                tmpList.sort(lambda x,y: -cmp(x.quality, y.quality)) 
     1423                tmpList = tmpList[:self.rule_filter.width] 
     1424                     
     1425                for tmpRule in tmpList: 
    14211426                    # if rule not in rules already, add it to the list 
    14221427                    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: 
     
    14351440        return new_rules 
    14361441 
    1437  
    14381442    def init_pos_args(self, ae, examples, weight_id): 
    14391443        pos_args = RuleList() 
     
    14411445        for p in ae[self.argument_id].value.positiveArguments: 
    14421446            new_arg = Rule(filter=ArgFilter(argument_id = self.argument_id, 
    1443                                                    filter = self.newFilter_values(p.filter)), 
     1447                                                   filter = self.newFilter_values(p.filter), 
     1448                                                   arg_example = ae), 
    14441449                                                   complexity = 0) 
    14451450            new_arg.valuesFilter = new_arg.filter.filter 
     
    14551460        for p in pos_args: 
    14561461            p.filterAndStore(examples, weight_id, 0) 
     1462            if not p.learner: 
     1463                p.learner = DefaultLearner(defaultValue=ae.getclass()) 
    14571464            # pruning on: we check on all conditions and take only best 
    14581465            if self.prune_arguments: 
     
    14741481                    if not (u.position, u.oper) in at_oper_pairs: 
    14751482                        # find minimum value 
    1476                         u.ref = min([float(e[u.position])-10. for e in p.examples]) 
     1483                        if u.oper == Orange.core.ValueFilter_continuous.Greater or u.oper == Orange.core.ValueFilter_continuous.GreaterEqual: 
     1484                            u.ref = min([float(e[u.position])-10. for e in p.examples]) 
     1485                        else: 
     1486                            u.ref = max([float(e[u.position])+10. for e in p.examples]) 
    14771487                        p.filter.conditions.append(u) 
    14781488                        p.filter.filter.conditions.append(u) 
    14791489                 
    1480  
    14811490        # set parameters to arguments 
    14821491        for p_i,p in enumerate(pos_args): 
    14831492            p.filterAndStore(examples,weight_id,0) 
    14841493            p.filter.domain = examples.domain 
    1485             if not p.learner: 
    1486                 p.learner = DefaultLearner(default_value=ae.getclass()) 
    14871494            p.classifier = p.learner(p.examples, p.weight_id) 
    1488             p.baseDist = p.class_distribution 
    14891495            p.requiredConditions = len(p.filter.conditions) 
    1490             p.learner.setattr("arg_length", len(p.filter.conditions)) 
    14911496            p.learner.setattr("arg_example", ae) 
    14921497            p.complexity = len(p.filter.conditions) 
Note: See TracChangeset for help on using the changeset viewer.