Changeset 9475:94248b7f0b44 in orange


Ignore:
Timestamp:
08/12/11 04:43:40 (3 years ago)
Author:
wencanluo <wencanluo@…>
Branch:
default
Convert:
464790092801066721987a9584582f8d247c59ff
Message:

Add test codes for multi-label classifications

Location:
orange
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • orange/Orange/evaluation/scoring.py

    r9468 r9475  
    26152615                raise ValueError, "The dimensions of the classified output and the actual class array do not match." 
    26162616            for j in range(label_num): 
    2617                 if labels[j] == aclass[j]: 
     2617                if labels[j] <> aclass[j]: 
    26182618                    losses[i] = losses[i]+1 
    26192619             
  • orange/Orange/multilabel/br.py

    r9474 r9475  
    6464    Class that implements the Binary Relevance (BR) method.  
    6565    """ 
    66     def __new__(cls, instances = None, base_learner = None, **argkw): 
     66    def __new__(cls, instances = None, base_learner = None, weight_id = 0, **argkw): 
    6767        self = _multibase.MultiLabelLearner.__new__(cls, **argkw) 
    6868        if base_learner: 
     
    7373        if instances: 
    7474            self.__init__(**argkw) 
    75             return self.__call__(instances,base_learner) 
     75            return self.__call__(instances,base_learner,weight_id) 
    7676        else: 
    7777            return self 
    7878         
    79     def __call__(self, instances, base_learner = None, **kwds): 
     79    def __call__(self, instances, base_learner = None, weight_id = 0, **kwds): 
    8080        for k in kwds.keys(): 
    8181            self.__dict__[k] = kwds[k] 
     
    107107             
    108108        #Learn from the given table of data instances. 
    109         return BinaryRelevanceClassifier(instances = instances, label_indices = label_indices,classifiers = classifiers) 
     109        return BinaryRelevanceClassifier(instances = instances,  
     110                                         label_indices = label_indices, 
     111                                         classifiers = classifiers, 
     112                                         weight_id = weight_id) 
    110113 
    111114class BinaryRelevanceClassifier(_multibase.MultiLabelClassifier): 
     
    149152        return labels,disc 
    150153         
     154######################################################################################### 
     155if __name__ == "__main__": 
     156    data = Orange.data.Table("emotions.tab") 
     157 
     158    classifier = Orange.multilabel.BinaryRelevanceLearner(data,Orange.classification.knn.kNNLearner) 
     159    for i in range(10): 
     160        c,p = classifier(data[i],Orange.classification.Classifier.GetBoth) 
     161        print c,p 
  • orange/Orange/multilabel/brknn.py

    r9474 r9475  
    7171     
    7272    """ 
    73     def __new__(cls, instances = None, k=1, ext = None, **argkw): 
     73    def __new__(cls, instances = None, k=1, ext = None, weight_id = 0, **argkw): 
    7474        """ 
    7575        Constructor of BRkNNLearner 
     
    9696            self.instances = instances 
    9797            self.__init__(**argkw) 
    98             return self.__call__(instances) 
     98            return self.__call__(instances,weight_id) 
    9999        else: 
    100100            return self 
    101101 
    102     def __call__(self, instances, **kwds): 
     102    def __call__(self, instances, weight_id = 0, **kwds): 
    103103        for k in kwds.keys(): 
    104104            self.__dict__[k] = kwds[k] 
     
    163163        total = 0 
    164164        weight = 0 
    165         neighborLabels = 0 
     165        neighbor_labels = 0 
    166166        confidences = [0.0]* self.num_labels 
    167167 
     
    185185                if value == '1': 
    186186                    confidences[j] += weight 
    187                     neighborLabels += weight 
     187                    neighbor_labels += weight 
    188188            total += weight 
    189189 
    190         self.avgPredictedLabels = math.ceil(neighborLabels / total) 
     190        self.avg_predicted_labels = int(math.ceil(neighbor_labels / total)) 
    191191         
    192192        #Normalise distribution 
     
    258258 
    259259        for i in range(self.num_labels): 
    260             if prob[i] > prob[self.num_labels - self.avgPredictedLabels]: 
     260            if prob[i] > prob[self.num_labels - self.avg_predicted_labels]: 
    261261                labels[i].value = '1' 
    262262                counter = counter + 1 
    263             elif prob[i] == prob[self.num_labels - self.avgPredictedLabels]: 
     263            elif prob[i] == prob[self.num_labels - self.avg_predicted_labels]: 
    264264                indices.append(i) 
    265265 
    266266        size = len(indices) 
    267267 
    268         j = avgPredictedLabels - counter 
     268        j = self.avg_predicted_labels - counter 
    269269        while j > 0: 
    270             next = rrandom.randint(0,size-1) 
     270            next = random.randint(0,size-1) 
    271271            if labels[indices[next]] <> '1': 
    272272                labels[indices[next]] = '1' 
     
    275275        return labels        
    276276     
     277######################################################################################### 
     278if __name__ == "__main__": 
     279    data = Orange.data.Table("emotions.tab") 
     280 
     281    classifier = Orange.multilabel.BRkNNLearner(data,5) 
     282    for i in range(10): 
     283        c,p = classifier(data[i],Orange.classification.Classifier.GetBoth) 
     284        print c,p 
  • orange/Orange/multilabel/lp.py

    r9474 r9475  
    6060    Class that implements the LabelPowerset (LP) method.  
    6161    """ 
    62     def __new__(cls, instances = None, base_learner = None, **argkw): 
     62    def __new__(cls, instances = None, base_learner = None, weight_id = 0, **argkw): 
    6363        self = _multibase.MultiLabelLearner.__new__(cls, **argkw) 
    6464        if base_learner: 
     
    6969        if instances: 
    7070            self.__init__(**argkw) 
    71             return self.__call__(instances,base_learner) 
     71            return self.__call__(instances,base_learner,weight_id) 
    7272        else: 
    7373            return self 
    7474                 
    75     def __call__(self, instances, base_learner = None, **kwds): 
     75    def __call__(self, instances, base_learner = None, weight_id = 0, **kwds): 
    7676        for k in kwds.keys(): 
    7777            self.__dict__[k] = kwds[k] 
     
    103103             
    104104            new_table.append(new_row) 
    105                       
     105              
    106106        #store the classifier 
    107107        classifier = self.base_learner(new_table) 
    108108         
    109109        #Learn from the given table of data instances. 
    110         return LabelPowersetClassifier(instances = instances, label_indices = label_indices,classifier = classifier) 
     110        return LabelPowersetClassifier(instances = instances,  
     111                                       label_indices = label_indices, 
     112                                       classifier = classifier, 
     113                                       weight_id = weight_id) 
    111114 
    112115class LabelPowersetClassifier(_multibase.MultiLabelClassifier):       
     
    139142            return disc 
    140143        return labels,disc 
    141          
     144 
     145######################################################################################### 
     146if __name__ == "__main__": 
     147    data = Orange.data.Table("emotions.tab") 
     148 
     149    classifier = Orange.multilabel.LabelPowersetLearner(data,Orange.classification.knn.kNNLearner) 
     150    for i in range(10): 
     151        c,p = classifier(data[i],Orange.classification.Classifier.GetBoth) 
     152        print c,p 
  • orange/Orange/multilabel/mlknn.py

    r9474 r9475  
    119119     
    120120    """ 
    121     def __new__(cls, instances = None, k=1, smooth = 1.0, **argkw): 
     121    def __new__(cls, instances = None, k=1, smooth = 1.0, weight_id = 0, **argkw): 
    122122        """ 
    123123        Constructor of MLkNNLearner 
     
    140140         
    141141        if instances: 
    142             self.instances = instances 
    143142            self.__init__(**argkw) 
    144             return self.__call__(instances) 
     143            return self.__call__(instances,weight_id) 
    145144        else: 
    146145            return self 
    147146 
    148     def __call__(self, instances, **kwds): 
     147    def __call__(self, instances, weight_id = 0, **kwds): 
    149148        for k in kwds.keys(): 
    150149            self.__dict__[k] = kwds[k] 
     
    168167         
    169168        #Computing the prior probabilities P(H_b^l) 
    170         self.compute_prior() 
     169        self.compute_prior(instances) 
    171170         
    172171        #Computing the posterior probabilities P(E_j^l|H_b^l) 
    173         self.compute_cond() 
    174          
    175         return MLkNNClassifier(instances = self.instances, label_indices = self.label_indices,  
     172        self.compute_cond(instances) 
     173         
     174        return MLkNNClassifier(instances = instances, label_indices = self.label_indices,  
    176175                               prior_probabilities = self.prior_probabilities,  
    177176                               prior_nprobabilities = self.prior_nprobabilities, 
     
    179178                               cond_nprobabilities = self.cond_nprobabilities, 
    180179                               knn = self.knn, 
    181                                k = self.k) 
    182  
    183     def compute_prior(self): 
     180                               k = self.k, 
     181                               weight_id = weight_id) 
     182 
     183    def compute_prior(self,instances): 
    184184        """ Computing Prior and PriorN Probabilities for each class of the training set """ 
    185         num_instances = len(self.instances) 
     185        num_instances = len(instances) 
    186186        for i in range(self.num_labels): 
    187187            temp_ci = 0 
    188188            for j in range(num_instances): 
    189                 value = self.instances[j][self.label_indices[i]].value 
     189                value = instances[j][self.label_indices[i]].value 
    190190                if value == '1': 
    191191                    temp_ci = temp_ci+1 
     
    193193            self.prior_nprobabilities[i] = 1 - self.prior_probabilities[i] 
    194194             
    195     def compute_cond(self): 
     195    def compute_cond(self,instances): 
    196196        """ Computing Cond and CondN Probabilities for each class of the training set """ 
    197197        num_labels = self.num_labels 
    198198        label_indices = self.label_indices 
    199199        k = self.k 
    200         num_instances = len(self.instances) 
    201         instances = self.instances 
     200        num_instances = len(instances) 
    202201         
    203202        temp_ci  = [ [0] * (k + 1) ] * num_labels 
     
    278277        return labels,disc 
    279278         
     279######################################################################################### 
     280if __name__ == "__main__": 
     281    data = Orange.data.Table("emotions.tab") 
     282 
     283    classifier = Orange.multilabel.MLkNNLearner(data,5,1.0) 
     284    for i in range(10): 
     285        c,p = classifier(data[i],Orange.classification.Classifier.GetBoth) 
     286        print c,p 
  • orange/OrangeWidgets/Evaluate/OWTestLearners.py

    r9472 r9475  
    436436            #self.statLayout.setCurrentWidget(self.cbox if self.isclassification() else self.rbox) 
    437437             
     438            print multilabel_flag 
    438439            #self.stat = [self.rStatistics, self.cStatistics][self.isclassification()] 
    439             self.stat = self.set_newstate() 
    440440            if multilabel_flag == 1: 
    441441                self.statLayout.setCurrentWidget(self.mbox) 
     
    445445            if self.learners: 
    446446                self.score([l.id for l in self.learners.values()]) 
    447  
     447            self.stat = self.set_newstate() 
     448             
    448449        self.openContext("", data) 
    449450        self.paintscores() 
Note: See TracChangeset for help on using the changeset viewer.