Changeset 7794:19b30304811f in orange


Ignore:
Timestamp:
03/31/11 13:54:12 (3 years ago)
Author:
ales_erjavec <ales.erjavec@…>
Branch:
default
Convert:
cfc6221aedf70868a94f1ff6180191e605474709
Message:

Moved the Preprocessors implemented in OWPreprocess.py to Orange.preprocessors module.

Location:
orange
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • orange/Orange/misc/__init__.py

    r7778 r7794  
    424424                    doc="A deprecated member '%s'. Use '%s' instead." % (old_name, new_name)) 
    425425    return prop 
    426      
    427 def _test(): 
    428     import doctest 
    429     doctest.testmod() 
    430      
    431 if __name__ == "__main__": 
    432     _test() 
     426 
     427 
     428""" 
     429Some utility functions common to Orange classes. 
     430  
     431""" 
     432 
     433def _orange__new__(base=None): 
     434    """ Return an orange 'schizofrenic' __new__ class method. 
     435     
     436    :param base: base orange class (default orange.Learner) 
     437    :type base: type 
     438          
     439    Example:: 
     440        class NewOrangeLearner(orange.Learner): 
     441            __new__ = _orange__new(orange.Learner) 
     442         
     443    """ 
     444    if base is None: 
     445        import Orange 
     446        base = Orange.core.Learner 
     447         
     448    @wraps(base.__new__) 
     449    def _orange__new_wrapped(cls, data=None, **kwargs): 
     450        self = base.__new__(cls, **kwargs) 
     451        if data: 
     452            self.__init__(**kwargs) 
     453            return self.__call__(data) 
     454        else: 
     455            return self 
     456    return _orange__new_wrapped 
     457 
     458 
     459def _orange__reduce__(self): 
     460    """ A default __reduce__ method for orange types. Assumes the object 
     461    can be reconstructed with the call `constructor(__dict__)` where __dict__ 
     462    if the stored (pickled) __dict__ attribute. 
     463     
     464    Example:: 
     465        class NewOrangeType(orange.Learner): 
     466            __reduce__ = _orange__reduce() 
     467    """  
     468    return type(self), (), dict(self.__dict__) 
     469     
  • orange/Orange/preprocess/__init__.py

    r7780 r7794  
    8282 
    8383import outliers 
     84 
     85 
     86 
     87import orange 
     88from Orange.misc import _orange__new__, _orange__reduce__ 
     89 
     90class Preprocessor_discretizeEntropy(Preprocessor_discretize): 
     91    """ An discretizer that uses orange.EntropyDiscretization method but, 
     92    unlike Preprocessor_discretize class, also removes unused attributes 
     93    from the domain. 
     94     
     95    """ 
     96     
     97    __new__ = _orange__new__(Preprocessor_discretize) 
     98    __reduce__ = _orange__reduce__ 
     99     
     100    def __init__(self, method=orange.EntropyDiscretization()): 
     101        self.method = method 
     102        assert(isinstance(method, orange.EntropyDiscretization)) 
     103         
     104    def __call__(self, data, wightId=0): 
     105        newattr_list = [] 
     106        for attr in data.domain.attributes: 
     107            if attr.varType == orange.VarTypes.Continuous: 
     108                newattr = self.method(attr, data) 
     109                if newattr.getValueFrom.transformer.points: 
     110                    newattr_list.append(newattr) 
     111            else: 
     112                newattr_list.append(attr) 
     113        newdomain = orange.Domain(newattr_list, data.domain.classVar) 
     114        newdomain.addmetas(data.domain.getmetas()) 
     115        return orange.ExampleTable(newdomain, data) 
     116     
     117class Preprocessor_removeContinuous(Preprocessor_discretize): 
     118    """ A preprocessor that removes all continuous features. 
     119    """ 
     120    __new__ = _orange__new__(Preprocessor_discretize) 
     121    __reduce__ = _orange__reduce__ 
     122     
     123    def __call__(self, data, weightId=None): 
     124        attrs = [attr for attr in data.domain.attributes if attr.varType == orange.VarTypes.Discrete] 
     125        domain = orange.Domain(attrs, data.domain.classVar) 
     126        domain.addmetas(data.domain.getmetas()) 
     127        return orange.ExampleTable(domain, data) 
     128                 
     129class Preprocessor_continuize(orange.Preprocessor): 
     130    """ A preprocessor that continuizes a discrete domain (and optionally normalizes it). 
     131    See :obj:`Orange.feature.continuization.DomainContinuizer` for list of accepted arguments. 
     132     
     133    """ 
     134    __new__ = _orange__new__(orange.Preprocessor) 
     135    __reduce__ = _orange__reduce__ 
     136     
     137    def __init__(self, zeroBased=True, multinomialTreatment=orange.DomainContinuizer.NValues, normalizeContinuous=False, **kwargs): 
     138        self.zeroBased = zeroBased 
     139        self.multinomialTreatment = multinomialTreatment 
     140        self.normalizeContinuous = normalizeContinuous 
     141             
     142    def __call__(self, data, weightId=0): 
     143        continuizer = orange.DomainContinuizer(zeroBased=self.zeroBased, 
     144                                               multinomialTreatment=self.multinomialTreatment, 
     145                                               normalizeContinuous=self.normalizeContinuous, 
     146                                               classTreatment=orange.DomainContinuizer.Ignore) 
     147        c_domain = continuizer(data, weightId) 
     148        return data.translate(c_domain) 
     149     
     150class Preprocessor_removeDiscrete(Preprocessor_continuize): 
     151    """ A Preprocessor that removes all discrete attributes from the domain. 
     152    """ 
     153    __new__ = _orange__new__(Preprocessor_continuize) 
     154     
     155    def __call__(self, data, weightId=None): 
     156        attrs = [attr for attr in data.domain.attributes if attr.varType == orange.VarTypes.Continuous] 
     157        domain = orange.Domain(attrs, data.domain.classVar) 
     158        domain.addmetas(data.domain.getmetas()) 
     159        return orange.ExampleTable(domain, data) 
     160          
     161class Preprocessor_impute(orange.Preprocessor): 
     162    """ A preprocessor that imputes unknown values using a learner. 
     163     
     164    :param model: a learner class. 
     165     
     166    """ 
     167    __new__ = _orange__new__(orange.Preprocessor) 
     168    __reduce__ = _orange__reduce__ 
     169     
     170    def __init__(self, model=None, **kwargs): 
     171        self.model = orange.MajorityLearner() if model is None else model 
     172         
     173    def __call__(self, data, weightId=0): 
     174        return orange.Preprocessor_imputeByLearner(data, learner=self.model) 
     175 
     176def bestN(attrMeasures, N=10): 
     177    """ Return best N attributes  
     178    """ 
     179    return attrMeasures[-N:] 
     180 
     181def bestP(attrMeasures, P=10): 
     182    """ Return best P percent of attributes 
     183    """ 
     184    count = len(attrMeasures) 
     185    return  attrMeasures[-max(int(math.ceil(count * P / 100.0)), 1):] 
     186 
     187class Preprocessor_featureSelection(orange.Preprocessor): 
     188    """ A preprocessor that runs feature selection using an feature scoring function. 
     189     
     190    :param measure: a scoring function (default: orange.MeasureAttribute_relief) 
     191    :param filter: a filter function to use for selection (default Preprocessor_featureSelection.bestN) 
     192    :param limit: the limit for the filter function (default 10) 
     193         
     194    """ 
     195    __new__ = _orange__new__(orange.Preprocessor) 
     196    __reduce__ = _orange__reduce__ 
     197     
     198    bestN = staticmethod(bestN) 
     199    bestP = staticmethod(bestP) 
     200     
     201    def __init__(self, measure=orange.MeasureAttribute_relief(), filter=None, limit=10): 
     202        self.measure = measure 
     203        self.filter = filter if filter is not None else self.bestN 
     204        self.limit = limit 
     205     
     206    def attrScores(self, data): 
     207        """ Return a list of computed scores for all attributes in `data`.  
     208        """ 
     209        measures = [(self.measure(attr, data), attr) for attr in data.domain.attributes] 
     210        return measures 
     211          
     212    def __call__(self, data, weightId=None): 
     213        measures = self.attrScores(data) 
     214        attrs = [attr for _, attr in self.filter(measures, self.limit)] 
     215        domain = orange.Domain(attrs, data.domain.classVar) 
     216        domain.addmetas(data.domain.getmetas()) 
     217        return orange.ExampleTable(domain, data) 
     218     
     219class Preprocessor_RFE(Preprocessor_featureSelection): 
     220    """ A preprocessor that runs RFE(Recursive Feature Elimination) using 
     221    linear SVM derived attribute weights. 
     222     
     223    :param filter: a filter function to use for selection (default 
     224                   Preprocessor_featureSelection.bestN) 
     225    :param limit: the limit for the filter function (default 10) 
     226         
     227    """ 
     228    __new__ = _orange__new__(Preprocessor_featureSelection) 
     229    __reduce__ = _orange__reduce__ 
     230    def __init__(self, filter=None, limit=10): 
     231        self.limit = limit 
     232        self.filter = filter if filter is not None else self.bestN 
     233         
     234    def __call__(self, data, weightId=None): 
     235        from Orange.classification.svm import RFE 
     236        rfe = RFE() 
     237        filtered = self.filter(range(len(data)), self.limit) 
     238        return rfe(data, len(filtered)) 
     239     
     240def selectNRandom(examples, N=10): 
     241    """ Select N random examples. 
     242    """ 
     243    import random 
     244    return random.sample(examples, N) 
     245 
     246def selectPRandom(examples, P=10): 
     247    """ Select P percent random examples. 
     248    """ 
     249    import random 
     250    count = len(examples) 
     251    return random.sample(examples, max(int(math.ceil(count * P / 100.0)), 1)) 
     252 
     253class Preprocessor_sample(orange.Preprocessor): 
     254    """ A preprocessor that samples a subset of the data. 
     255     
     256    :param filter: a filter function to use for selection (default 
     257                   Preprocessor_sample.selectNRandom) 
     258    :param limit: the limit for the filter function (default 10) 
     259     
     260    """ 
     261    __new__ = _orange__new__(orange.Preprocessor) 
     262    __reduce__ = _orange__reduce__ 
     263 
     264    selectNRandom = staticmethod(selectNRandom) 
     265    selectPRandom = staticmethod(selectPRandom) 
     266     
     267    def __init__(self, filter=None, limit=10): 
     268        self.filter = filter if filter is not None else self.selectNRandom 
     269        self.limit = limit 
     270         
     271    def __call__(self, data, weightId=None): 
     272        return orange.ExampleTable(data.domain, self.filter(data, self.limit)) 
     273     
     274 
     275class Preprocessor_preprocessorList(orange.Preprocessor): 
     276    """ A preprocessor wrapping a sequence of other preprocessors. 
     277     
     278    :param preprocessors: a list of :obj:`Preprocessor` instances 
     279     
     280    """ 
     281     
     282    __new__ = _orange__new__(orange.Preprocessor) 
     283    __reduce__ = _orange__reduce__ 
     284     
     285    def __init__(self, preprocessors=[]): 
     286        self.preprocessors = preprocessors 
     287         
     288    def __call__(self, data, weightId=None): 
     289        import orange 
     290        hadWeight = hasWeight = weightId is not None 
     291        for preprocessor in self.preprocessors: 
     292            t = preprocessor(data, weightId) if hasWeight else preprocessor(data) 
     293            if isinstance(t, tuple): 
     294                data, weightId = t 
     295                hasWeight = True 
     296            else: 
     297                data = t 
     298        if hadWeight: 
     299            return data, weightId 
     300        else: 
     301            return data 
     302         
  • orange/OrangeWidgets/Data/OWPreprocess.py

    r7105 r7794  
    1717import math 
    1818 
    19 from orange import Preprocessor_discretize, Preprocessor_imputeByLearner, Preprocessor_dropMissing 
     19from Orange.preprocess import * 
    2020 
    2121def _gettype(obj): 
     
    2626    else: 
    2727        return type(obj) 
    28  
    29 def _orange__reduce(self): 
    30     """ A default __reduce__ method for orange types. 
    31      
    32     Example:: 
    33         class NewOrangeType(orange.Learner): 
    34             __reduce__ = _orange__reduce() 
    35     """  
    36     return type(self), (), dict(self.__dict__) 
    37      
    38 def _orange__new(base=orange.Preprocessor): 
    39     """ Return an orange 'schizofrenic' __new__ class method. 
    40      
    41     Arguments: 
    42         - `base`: base orange class (default orange.Preprocessor) 
    43           
    44     Example:: 
    45         class NewOrangeType(orange.Learner): 
    46             __new__ = _orange__new() 
    47          
    48     """ 
    49     def _orange__new_wrapped(cls, data=None, **kwargs): 
    50         self = base.__new__(cls, **kwargs) 
    51         if data: 
    52             self.__init__(kwargs) 
    53             return self.__call__(data) 
    54         else: 
    55             return self 
    56     return _orange__new_wrapped 
    57  
    58 class Preprocessor_discretizeEntropy(Preprocessor_discretize): 
    59     """ An discretizer that uses orange.EntropyDiscretization method but, 
    60     unlike Preprocessor_disctetize class, also removes unused attributes 
    61     from the domain. 
    62     """ 
    63      
    64     __new__ = _orange__new(Preprocessor_discretize) 
    65     __reduce__ = _orange__reduce 
    66      
    67     def __init__(self, method=orange.EntropyDiscretization()): 
    68         self.method = method 
    69         assert(isinstance(method, orange.EntropyDiscretization)) 
    70          
    71     def __call__(self, data, wightId=0): 
    72         newattr_list = [] 
    73         for attr in data.domain.attributes: 
    74             if attr.varType == orange.VarTypes.Continuous: 
    75                 newattr = self.method(attr, data) 
    76                 if newattr.getValueFrom.transformer.points: 
    77                     newattr_list.append(newattr) 
    78             else: 
    79                 newattr_list.append(attr) 
    80         newdomain = orange.Domain(newattr_list, data.domain.classVar) 
    81         newdomain.addmetas(data.domain.getmetas()) 
    82         return orange.ExampleTable(newdomain, data) 
    83      
    84 class Preprocessor_removeContinuous(Preprocessor_discretize): 
    85     """ A preprocessor that removes all continuous attributes. 
    86     """ 
    87     __new__ = _orange__new(Preprocessor_discretize) 
    88     __reduce__ = _orange__reduce 
    89      
    90     def __call__(self, data, weightId=None): 
    91         attrs = [attr for attr in data.domain.attributes if attr.varType == orange.VarTypes.Discrete] 
    92         domain = orange.Domain(attrs, data.domain.classVar) 
    93         domain.addmetas(data.domain.getmetas()) 
    94         return orange.ExampleTable(domain, data) 
    95                  
    96 class Preprocessor_continuize(orange.Preprocessor): 
    97     """ A preprocessor that continuizes a discrete domain (and optionaly normalizes it). 
    98     See DomainContinuizer for list of accepted arguments.   
    99     """ 
    100     __new__ = _orange__new() 
    101     __reduce__ = _orange__reduce 
    102      
    103     def __init__(self, zeroBased=True, multinomialTreatment=orange.DomainContinuizer.NValues, normalizeContinuous=False, **kwargs): 
    104         self.zeroBased = zeroBased 
    105         self.multinomialTreatment = multinomialTreatment 
    106         self.normalizeContinuous = normalizeContinuous 
    107              
    108     def __call__(self, data, weightId=0): 
    109         continuizer = orange.DomainContinuizer(zeroBased=self.zeroBased, 
    110                                                multinomialTreatment=self.multinomialTreatment, 
    111                                                normalizeContinuous=self.normalizeContinuous, 
    112                                                classTreatment=orange.DomainContinuizer.Ignore) 
    113         c_domain = continuizer(data, weightId) 
    114         return data.translate(c_domain) 
    115      
    116 class Preprocessor_removeDiscrete(Preprocessor_continuize): 
    117     """ A Preprocessor that removes all discrete attributes from the domain. 
    118     """ 
    119     __new__ = _orange__new(Preprocessor_continuize) 
    120      
    121     def __call__(self, data, weightId=None): 
    122         attrs = [attr for attr in data.domain.attributes if attr.varType == orange.VarTypes.Continuous] 
    123         domain = orange.Domain(attrs, data.domain.classVar) 
    124         domain.addmetas(data.domain.getmetas()) 
    125         return orange.ExampleTable(domain, data) 
    126           
    127 class Preprocessor_impute(orange.Preprocessor): 
    128     """ A preprocessor that imputes unknown values using a learner. 
    129     Arguments: 
    130         - `model`: a learner class 
    131     """ 
    132     __new__ = _orange__new() 
    133     __reduce__ = _orange__reduce 
    134      
    135     def __init__(self, model=None, **kwargs): 
    136         self.model = orange.MajorityLearner() if model is None else model 
    137          
    138     def __call__(self, data, weightId=0): 
    139         return orange.Preprocessor_imputeByLearner(data, learner=self.model) 
    140  
    141 def bestN(attrMeasures, N=10): 
    142     """ Return best N attributes  
    143     """ 
    144     return attrMeasures[-N:] 
    145  
    146 def bestP(attrMeasures, P=10): 
    147     """ Return best P percent of attributes 
    148     """ 
    149     count = len(attrMeasures) 
    150     return  attrMeasures[-max(int(math.ceil(count * P / 100.0)), 1):] 
    151  
    152 class Preprocessor_featureSelection(orange.Preprocessor): 
    153     """ A preprocessor that runs feature selection using an feature scoring function. 
    154     Arguments: 
    155         - `measure`: a scoring function (default: orange.MeasureAttribute_relief) 
    156         - `filter`: a filter function to use for selection (default Preprocessor_featureSelection.bestN 
    157         - `limit`: the number of selected features (default 10) 
    158          
    159     """ 
    160     __new__ = _orange__new() 
    161     __reduce__ = _orange__reduce 
    162      
    163     bestN = staticmethod(bestN) 
    164     bestP = staticmethod(bestP) 
    165      
    166     def __init__(self, measure=orange.MeasureAttribute_relief(), filter=None, limit=10): 
    167         self.measure = measure 
    168         self.filter = filter if filter is not None else self.bestN 
    169         self.limit = limit 
    170      
    171     def attrScores(self, data): 
    172         measures = [(self.measure(attr, data), attr) for attr in data.domain.attributes] 
    173         return measures 
    174           
    175     def __call__(self, data, weightId=None): 
    176         measures = self.attrScores(data) 
    177         attrs = [attr for _, attr in self.filter(measures, self.limit)] 
    178         domain = orange.Domain(attrs, data.domain.classVar) 
    179         domain.addmetas(data.domain.getmetas()) 
    180         return orange.ExampleTable(domain, data) 
    181      
    182 class Preprocessor_RFE(Preprocessor_featureSelection): 
    183     """ A preprocessor that runs RFE(Recursive feature elimination) using linear SVM derived attribute weights. 
    184     Arguments: 
    185         - `filter`: a filter function to use for selection (default Preprocessor_featureSelection.bestN 
    186         - `limit`: The number of selected features (default 10) 
    187          
    188     """ 
    189     __new__ = _orange__new(Preprocessor_featureSelection) 
    190     __reduce__ = _orange__reduce 
    191     def __init__(self, filter=None, limit=10): 
    192         self.limit = limit 
    193         self.filter = filter if filter is not None else self.bestN 
    194          
    195     def __call__(self, data, weightId=None): 
    196         from orngSVM import RFE 
    197         rfe = RFE() 
    198         filterd = self.filter(range(len(self.data)), self.limit) 
    199         return rfe(data, len(filterd)) 
    200      
    201 def selectNRandom(examples, N=10): 
    202     """ Select N random examples 
    203     """ 
    204     import random 
    205     return random.sample(examples, N) 
    206  
    207 def selectPRandom(examples, P=10): 
    208     """ Select P percent random examples 
    209     """ 
    210     import random 
    211     count = len(examples) 
    212     return random.sample(examples, max(int(math.ceil(count * P / 100.0)), 1)) 
    213  
    214 class Preprocessor_sample(orange.Preprocessor): 
    215     """ A preprocessor that samples a subset of the data: 
    216     Arguments: 
    217         - `filter`: a filter function to use for selection (default Preprocessor_sample.selectNRandom) 
    218         - `limit`: the limit for the filter function (default 10) 
    219     """ 
    220     __new__ = _orange__new() 
    221     __reduce__ = _orange__reduce 
    222  
    223     selectNRandom = staticmethod(selectNRandom) 
    224     selectPRandom = staticmethod(selectPRandom) 
    225      
    226     def __init__(self, filter=None, limit=10): 
    227         self.filter = filter if filter is not None else self.selectNRandom 
    228         self.limit = limit 
    229          
    230     def __call__(self, data, weightId=None): 
    231         return orange.ExampleTable(data.domain, self.filter(data, self.limit)) 
    232      
    233  
    234 class Preprocessor_preprocessorList(orange.Preprocessor): 
    235     """ A preprocessor wrapping a sequence of other preprocessors 
    236     """ 
    237      
    238     __new__ = _orange__new() 
    239     __reduce__ = _orange__reduce 
    240      
    241     def __init__(self, preprocessors=[]): 
    242         self.preprocessors = preprocessors 
    243          
    244     def __call__(self, data, weightId=None): 
    245         import orange 
    246         hadWeight = hasWeight = weightId is not None 
    247         for preprocessor in self.preprocessors: 
    248             t = preprocessor(data, weightId) if hasWeight else preprocessor(data) 
    249             if isinstance(t, tuple): 
    250                 data, weightId = t 
    251                 hasWeight = True 
    252             else: 
    253                 data = t 
    254         if hadWeight: 
    255             return data, weightId 
    256         else: 
    257             return data 
    25828         
    25929def _pyqtProperty(type, **kwargs): 
Note: See TracChangeset for help on using the changeset viewer.