code: def _compute_centers(self, X, sparse, rs):
          
  
          # use supplied centers if present
          centers = self._get_user_components('centers')
  
          # use points taken uniformly from the bounding
          # hyperrectangle
          if (centers is None):
              n_features = X.shape[1]
  
              if (sparse):
                  fxr = range(n_features)
                  cols = [X.getcol(i) for i in fxr]
  
                  min_dtype = X.dtype.type(1.0e10)
                  sp_min = lambda col: np.minimum(min_dtype, np.min(col.data))
                  min_Xs = np.array(map(sp_min, cols))
  
                  max_dtype = X.dtype.type(-1.0e10)
                  sp_max = lambda col: np.maximum(max_dtype, np.max(col.data))
                  max_Xs = np.array(map(sp_max, cols))
              else:
                  min_Xs = X.min(axis=0)
                  max_Xs = X.max(axis=0)
  
              spans = max_Xs - min_Xs
              ctrs_size = (self.n_hidden, n_features)
              centers = min_Xs + spans * rs.uniform(0.0, 1.0, ctrs_size)
  
          self.components_['centers'] = centers
docs: Generate RBF centers