Changeset 3493:adc12428af14 in orange


Ignore:
Timestamp:
04/04/07 13:39:02 (7 years ago)
Author:
Gregor <Gregor@…>
Branch:
default
Convert:
4b3702fc68e4b31633af23c037e9f27f976be382
Message:
  • attrValues, attrSubValues
File:
1 edited

Legend:

Unmodified
Added
Removed
  • orange/orngScaleData.py

    r3413 r3493  
    1010 
    1111 
    12 # ####################################################################     
     12# #################################################################### 
    1313# return a list of sorted values for attribute at index index 
    1414# EXPLANATION: if variable values have values 1,2,3,4,... then their order in orange depends on when they appear first 
     
    1818        print "getVariableValuesSorted - attribute %s is a continuous variable" % (str(index)) 
    1919        return [] 
    20      
     20 
    2121    values = list(data.domain[index].values) 
    2222    intValues = [] 
     
    6969        newDomain = orange.Domain(data.domain.attributes, newClass) 
    7070        data = orange.ExampleTable(newDomain, data) 
    71      
     71 
    7272    for attr in data.domain.attributes: 
    7373        try: 
     
    8989 
    9090 
    91      
     91 
    9292class orngScaleData: 
    9393    def __init__(self): 
     
    108108        self.validDataArray = None 
    109109        self.validSubDataArray = None 
    110          
    111         
    112      
     110        self.attrValues = {} 
     111        self.attrSubValues = {} 
     112 
     113 
    113114    # Converts orange.ExampleTable to numpy.array based on the attribute values. 
    114115    # rows correspond to examples, columns correspond to attributes, class values are left out 
     
    131132        self.rawdata = data 
    132133        numpy.random.seed(1)     # we always reset the random generator, so that if we receive the same data again we will add the same noise 
    133                  
     134 
    134135        if data == None or len(data) == 0: 
    135136            self.originalData = self.scaledData = self.noJitteringScaledData = self.validDataArray = None 
    136137            return 
    137          
     138 
    138139        self.attributeFlipInfo = dict([(attr.name, 0) for attr in data.domain]) # reset the fliping information 
    139140 
     
    143144        self.attributeNames = [attr.name for attr in data.domain] 
    144145        self.attributeNameIndex = dict([(data.domain[i].name, i) for i in range(len(data.domain))]) 
    145          
    146         Min = -1; Max = -1 
    147         if self.globalValueScaling == 1: 
     146 
     147        if self.globalValueScaling: 
    148148            (Min, Max) = self.getMinMaxValDomain(data, self.attributeNames) 
    149149 
    150150        arr = MA.transpose(data.toNumpyMA("ac")[0]) 
    151151        averages = MA.average(arr, 1) 
    152         averages = MA.filled(averages, 1)   # replace missing values with 1 
    153         self.averages = averages.tolist() 
     152        self.averages = MA.filled(averages, 1)   # replace missing values with 1 
    154153        self.validDataArray = numpy.array(1-arr.mask, numpy.int)  # have to convert to int array, otherwise when we do some operations on this array we get overflow 
    155154        arr = numpy.array(MA.filled(arr, -99999999)) 
    156 ##        arr = numpy.array(MA.filled(arr, averages)) 
    157 ##        arr2 = numpy.zeros(arr.shape) 
    158 ##        for i in range(arr.shape[0]): 
    159 ##            arr2[i] = MA.filled(arr[i], averages[i]) 
    160 ##        self.originalData = arr2.copy() 
    161 ##        arr = arr2 
    162155        self.originalData = arr.copy() 
    163156        self.scaledData = numpy.zeros([len(data.domain), len(data)], numpy.float) 
    164157        self.noJitteringScaledData = numpy.zeros([len(data.domain), len(data)], numpy.float) 
    165158 
    166         # see if the values for discrete attributes have to be resorted  
     159        # see if the values for discrete attributes have to be resorted 
    167160        for index in range(len(data.domain)): 
    168161            attr = data.domain[index] 
    169              
     162 
    170163            if attr.varType == orange.VarTypes.Discrete: 
    171164                variableValueIndices = getVariableValueIndices(data, index, sortValuesForDiscreteAttrs) 
     
    179172                        break 
    180173 
    181                 if not self.attrValues.has_key(attr.name):  self.attrValues[attr.name] = [0, len(attr.values)] 
    182                 count = self.attrValues[attr.name][1] 
     174                count = len(attr.values) 
     175                self.attrValues[attr.name] = [0, count] 
    183176                arr[index] = (arr[index]*2.0 + 1.0)/ float(2*count) 
    184177                self.offsets.append(0.0) 
     
    212205                    self.scaledData[index] = arr[index] 
    213206 
    214             self.noJitteringScaledData = arr 
    215  
    216         if self.subsetData: 
    217             self.setSubsetData(self.subsetData) 
    218          
     207        self.noJitteringScaledData = arr 
     208#        if self.subsetData: 
     209#            self.setSubsetData(self.subsetData) 
     210 
    219211    def setSubsetData(self, subData): 
    220212        self.subsetData = subData 
    221213        self.validSubDataArray = [] 
     214        self.attrSubValues = {} 
     215        self.subDataMinMaxDict = {} 
     216 
     217#        if not subData or not self.rawdata or subData.domain.checksum() != self.rawdata.domain.checksum(): 
     218#            return 
     219 
     220        if not subData: 
     221            return 
    222222 
    223223        # create a  valid data array 
     
    225225        self.validSubDataArray = numpy.array(1-arr.mask, numpy.int)  # have to convert to int array, otherwise when we do some operations on this array we get overflow 
    226226 
    227         self.subDataMinMaxDict = {} 
    228         if not subData or not self.rawdata or subData.domain != self.rawdata.domain: 
    229             return 
    230         if self.scalingByVariance or self.globalValueScaling: return 
    231          
    232227        domainSubDataStat = orange.DomainBasicAttrStat(subData) 
    233228        for index in range(len(subData.domain)): 
     
    236231                Min = domainSubDataStat[index].min 
    237232                Max = domainSubDataStat[index].max 
     233                self.attrSubValues[attr.name] = (Min, Max) 
     234                if self.scalingByVariance or self.globalValueScaling: 
     235                    continue 
    238236                projMin = (Min - self.offsets[index]) / self.normalizers[index] 
    239237                projMax = (Max - self.offsets[index]) / self.normalizers[index] 
    240238                if projMin < 0.0 or projMax > 1.0: 
    241239                    self.subDataMinMaxDict[attr.name] = (min(projMin, 0.0), max(1.0, projMax)) 
    242  
    243   
    244     # #################################################################### 
    245     # compute min and max value for a list of attributes  
     240            elif subData.domain[index].varType == orange.VarTypes.Discrete: 
     241                self.attrSubValues[attr.name] = [0, len(attr.values)] 
     242 
     243    # #################################################################### 
     244    # compute min and max value for a list of attributes 
    246245    def getMinMaxValDomain(self, data, attrList): 
    247246        first = TRUE 
     
    257256                if maxVal > max: max = maxVal 
    258257        return (min, max) 
    259      
     258 
    260259 
    261260    # #################################################################### 
     
    270269        else: 
    271270            return (self.domainDataStat[index].min, self.domainDataStat[index].max) 
    272          
     271 
    273272    # #################################################################### 
    274273    # scale data at index index to the interval 0 to 1 
     
    281280 
    282281        arr = numpy.zeros([len(data)], numpy.float) 
    283          
     282 
    284283        # is the attribute discrete 
    285284        if attr.varType == orange.VarTypes.Discrete: 
     
    296295            if jitteringEnabled: 
    297296                arr = arr + 0.5 - (self.jitterSize/(50.0*count))*numpy.random.random(len(data)) 
    298              
     297 
    299298        # is the attribute continuous 
    300299        else: 
     
    305304            diff = max - min 
    306305            if diff == 0.0: diff = 1    # prevent division by zero 
    307              
     306 
    308307            for i in range(len(data)): 
    309308                if data[i][index].isSpecial() == 1: continue 
     
    317316        if example[index].isSpecial(): 
    318317            print "Warning: scaling example with missing value" 
    319             return 0.5     #1e20      
     318            return 0.5     #1e20 
    320319        if example.domain[index].varType == orange.VarTypes.Discrete: 
    321320            d = getVariableValueIndices(example, index) 
     
    330329                position = (position - m) / float(max(M-m, 1e-10)) 
    331330            return position 
    332          
     331 
    333332 
    334333    def rescaleAttributesGlobaly(self, data, attrList, jittering = 1): 
     
    353352        if self.rawdata.domain[attrName].varType == orange.VarTypes.Discrete: return 0 
    354353        if self.globalValueScaling: return 0 
    355              
     354 
    356355        index = self.attributeNameIndex[attrName] 
    357356        self.attributeFlipInfo[attrName] = not self.attributeFlipInfo[attrName] 
    358357        if self.rawdata.domain[attrName].varType == orange.VarTypes.Continuous: 
    359358            self.attrValues[attrName] = [-self.attrValues[attrName][1], -self.attrValues[attrName][0]] 
    360      
     359 
    361360        self.scaledData[index] = 1 - self.scaledData[index] 
    362361        self.noJitteringScaledData[index] = 1 - self.noJitteringScaledData[index] 
     
    385384        validList = self.getValidSubList(indices) 
    386385        return numpy.nonzero(validList)[0] 
    387          
     386 
    388387    # returns a number from -max to max 
    389388    def rndCorrection(self, max): 
    390389        if max == 0: return 0.0 
    391390        return (random() - 0.5)*2*max 
    392          
    393      
     391 
Note: See TracChangeset for help on using the changeset viewer.