Changeset 10307:d6d8086a228f in orange


Ignore:
Timestamp:
02/18/12 18:35:59 (2 years ago)
Author:
Miha Stajdohar <miha.stajdohar@…>
Branch:
default
Message:

The disp parameter in scipy.optimize.fmin_cobyla does not exist in scipy 0.7 (Debian stable).

File:
1 edited

Legend:

Unmodified
Added
Removed
  • Orange/regression/lasso.py

    r10294 r10307  
    138138    bootTable = Orange.data.Table(table.domain) 
    139139    for i in range(n): 
    140         id = numpy.random.randint(0,n) 
     140        id = numpy.random.randint(0, n) 
    141141        bootTable.append(table[id]) 
    142142    return bootTable 
     
    205205        self.set_imputer(imputer=imputer) 
    206206        self.set_continuizer(continuizer=continuizer) 
    207          
    208          
     207 
     208 
    209209    def __call__(self, table, weight=None): 
    210210        """ 
     
    217217            which stores weights for instances 
    218218         
    219         """   
     219        """ 
    220220        # dicrete values are continuized         
    221221        table = self.continuize_table(table) 
     
    226226        X, y, w = table.to_numpy() 
    227227        n, m = numpy.shape(X) 
    228          
     228 
    229229        X, mu_x, sigma_x = standardize(X) 
    230230        y, coef0 = center(y) 
    231          
     231 
    232232        t = self.t 
    233          
     233 
    234234        if self.s is not None: 
    235235            beta_full, rss, _, _ = numpy.linalg.lstsq(X, y) 
    236236            t = self.s * numpy.sum(numpy.abs(beta_full)) 
    237237            print "t =", t 
    238              
     238 
    239239        import scipy.optimize 
    240              
     240 
    241241        # objective function to be minimized 
    242242        objective = lambda beta: numpy.linalg.norm(y - numpy.dot(X, beta)) 
     
    246246        cnstr = lambda beta: t - numpy.sum(numpy.abs(beta)) 
    247247        # optimal solution 
    248         coefficients = scipy.optimize.fmin_cobyla(objective, beta_init,\ 
    249                                                        cnstr, disp=0) 
     248        coefficients = scipy.optimize.fmin_cobyla(objective, beta_init, cnstr) 
    250249 
    251250        # set small coefficients to 0 
     
    253252        coefficients = numpy.array(map(set_2_0, coefficients)) 
    254253        coefficients /= sigma_x 
    255          
     254 
    256255        # bootstrap estimator of standard error of the coefficient estimators 
    257256        # assumption: fixed t 
     
    277276                coeff_p.append(c.coefficients) 
    278277            p_vals = \ 
    279                    numpy.sum(abs(numpy.array(coeff_p))>\ 
     278                   numpy.sum(abs(numpy.array(coeff_p)) > \ 
    280279                             abs(numpy.array(coefficients)), \ 
    281                              axis=0)/float(self.n_perm) 
     280                             axis=0) / float(self.n_perm) 
    282281        else: 
    283282            p_vals = [float("nan")] * m 
     
    287286        dict_model = {} 
    288287        for i, var in enumerate(domain.attributes): 
    289             dict_model[var.name] = (coefficients[i], std_errors_fixed_t[i], p_vals[i])             
    290         
     288            dict_model[var.name] = (coefficients[i], std_errors_fixed_t[i], p_vals[i]) 
     289 
    291290        return LassoRegression(domain=domain, class_var=domain.class_var, 
    292291                               coef0=coef0, coefficients=coefficients, 
    293292                               std_errors_fixed_t=std_errors_fixed_t, 
    294293                               p_vals=p_vals, 
    295                                dict_model= dict_model, 
     294                               dict_model=dict_model, 
    296295                               mu_x=mu_x) 
    297296 
    298297deprecated_members({"nBoot": "n_boot", 
    299                     "nPerm": "n_perm"},  
     298                    "nPerm": "n_perm"}, 
    300299                   wrap_methods=["__init__"], 
    301300                   in_place=True)(LassoRegressionLearner) 
     
    334333        Sample mean of the all independent variables.     
    335334 
    336     """  
     335    """ 
    337336    def __init__(self, domain=None, class_var=None, coef0=None, 
    338337                 coefficients=None, std_errors_fixed_t=None, p_vals=None, 
     
    353352            variable will be predicted 
    354353        :type instance:  
    355         """   
     354        """ 
    356355        ins = Orange.data.Instance(self.domain, instance) 
    357356        if "?" in ins: # missing value -> corresponding coefficient omitted 
     
    362361            ins = numpy.array(ins.native())[:-1] - self.mu_x 
    363362 
    364         y_hat = numpy.dot(self.coefficients, ins) + self.coef0  
     363        y_hat = numpy.dot(self.coefficients, ins) + self.coef0 
    365364        y_hat = self.class_var(y_hat) 
    366365        dist = Orange.statistics.distribution.Continuous(self.class_var) 
     
    372371        else: 
    373372            return (y_hat, dist) 
    374          
     373 
    375374    @deprecated_keywords({"skipZero": "skip_zero"}) 
    376375    def to_string(self, skip_zero=True): 
     
    384383        :type skip_zero: boolean 
    385384        """ 
    386          
     385 
    387386        from string import join 
    388387        labels = ('Variable', 'Coeff Est', 'Std Error', 'p') 
    389388        lines = [join(['%10s' % l for l in labels], ' ')] 
    390389 
    391         fmt = "%10s " + join(["%10.3f"]*3, " ") + " %5s" 
     390        fmt = "%10s " + join(["%10.3f"] * 3, " ") + " %5s" 
    392391        fmt1 = "%10s %10.3f" 
    393392 
     
    399398            else: return " " 
    400399 
    401         stars =  get_star(self.p_vals[0]) 
     400        stars = get_star(self.p_vals[0]) 
    402401        lines.append(fmt1 % ('Intercept', self.coef0)) 
    403402        skipped = [] 
     
    405404            if self.coefficients[i] == 0. and skip_zero: 
    406405                skipped.append(self.domain.attributes[i].name) 
    407                 continue             
     406                continue 
    408407            stars = get_star(self.p_vals[i]) 
    409             lines.append(fmt % (self.domain.attributes[i].name,  
    410                          self.coefficients[i], self.std_errors_fixed_t[i],  
     408            lines.append(fmt % (self.domain.attributes[i].name, 
     409                         self.coefficients[i], self.std_errors_fixed_t[i], 
    411410                         self.p_vals[i], stars)) 
    412411        lines.append("Signif. codes:  0 *** 0.001 ** 0.01 * 0.05 . 0.1 empty 1") 
     
    437436 
    438437    import Orange 
    439      
    440     table = Orange.data.Table("housing.tab")         
     438 
     439    table = Orange.data.Table("housing.tab") 
    441440 
    442441    c = LassoRegressionLearner(table, t=len(table.domain)) 
Note: See TracChangeset for help on using the changeset viewer.