def __call__(self,x,y,amp=1.,scale=1.,symm=None,*args,**kwargs): if amp<0. or scale<0.: raise ValueError, 'The amp and scale parameters must be positive.' if symm is None: symm = (x is y) # Figure out how to divide job up between threads. nx = x.shape[0] ny = y.shape[0] n_threads = min(get_threadpool_size(), nx*ny / 10000) if n_threads > 1: if not symm: bounds = np.linspace(0,ny,n_threads+1) else: bounds = np.array(np.sqrt(np.linspace(0,ny*ny,n_threads+1)),dtype=int) # Split off the distance arguments distance_arg_dict = {} if hasattr(self.distance_fun, 'extra_parameters'): for key in self.extra_distance_params.iterkeys(): if key in kwargs.keys(): distance_arg_dict[key] = kwargs.pop(key) # Allocate the matrix C = np.asmatrix(np.empty((nx,ny),dtype=float,order='F')) def targ(C,x,y, cmin, cmax,symm, d_kwargs=distance_arg_dict, c_args=args, c_kwargs=kwargs): # Compute distance for this bit self.distance_fun(C, x, y, cmin=cmin, cmax=cmax, symm=symm, **d_kwargs) imul(C, 1./scale, cmin=cmin, cmax=cmax, symm=symm) # Compute covariance for this bit if self.with_x: self.cov_fun(C,x,y,cmin=cmin, cmax=cmax,symm=symm,*c_args,**c_kwargs) else: self.cov_fun(C, cmin=cmin, cmax=cmax,symm=symm, *c_args, **c_kwargs) imul(C, amp*amp, cmin=cmin, cmax=cmax, symm=symm) if n_threads <= 1: targ(C,x,y,0,-1,symm) else: thread_args = [(C,x,y,bounds[i],bounds[i+1],symm) for i in xrange(n_threads)] map_noreturn(targ, thread_args) if symm: symmetrize(C) return C
def spear_threading(x,y,idx,idy,sigma,tau,lags,wids,scales,symm=None,set_pmap=False,blocksize=10000) : """ threaded version, divide matrix into subblocks with *blocksize* elements each. Do not use it when multiprocessing is on (e.g., in emcee MCMC sampling). set_pmap needs to be turned on for the Pmap_Model. """ if (sigma<0. or tau<0.) : raise ValueError, 'The amp and scale parameters must be positive.' if (symm is None) : symm = (x is y) and (idx is idy) x = regularize_array(x) y = regularize_array(y) nx = x.shape[0] ny = y.shape[0] if np.isscalar(idx) : idx = np.ones(nx, dtype="int", order="F")*idx if np.isscalar(idy) : idy = np.ones(nx, dtype="int", order="F")*idy # Figure out how to divide job up between threads (along y) n_threads = min(get_threadpool_size(), nx*ny/blocksize) if n_threads > 1 : if not symm: # divide ny evenly if x is not y bounds = np.linspace(0,ny,n_threads+1) else : # divide ny*ny evenly in quadrature if x is y bounds = np.array(np.sqrt(np.linspace(0,ny*ny,n_threads+1)),dtype=int) # Allocate the matrix C = np.asmatrix(np.empty((nx,ny),dtype=float,order='F')) if set_pmap : def targ(C,x,y,idx,idy,cmin,cmax,symm) : SCF.covmatpmap_bit(C,x,y,idx,idy,sigma,tau,lags,wids,scales,cmin,cmax,symm) else : def targ(C,x,y,idx,idy,cmin,cmax,symm) : SCF.covmat_bit(C,x,y,idx,idy,sigma,tau,lags,wids,scales,cmin,cmax,symm) if n_threads <= 1 : targ(C,x,y,idx,idy,0,-1,symm) else : thread_args = [(C,x,y,idx,idy,bounds[i],bounds[i+1],symm) for i in xrange(n_threads)] map_noreturn(targ, thread_args) if symm: isotropic_cov_funs.symmetrize(C) return(C)
def brownian(x,y,amp=1.,scale=1.,origin=None,h=.5,symm=None): """ brownian(x,y,amp=1., scale=1.,h=.5,origin=None) Fractional n-dimensional brownian motion. h=.5 corresponds to standard Brownian motion. A covariance function. Remember, broadcasting for covariance functions works differently than for numpy universal functions. C(x,y) returns a matrix, and C(x) returns a vector. :Parameters: - `amp`: The pointwise standard deviation of f. - `scale`: The factor by which to scale the distance between points. Large value implies long-range correlation. - `h': The fractional parameter. - `x and y` are arrays of points in Euclidean coordinates formatted as follows: [[x_{0,0} ... x_{0,ndim}], [x_{1,0} ... x_{1,ndim}], ... [x_{N,0} ... x_{N,ndim}]] - `symm` indicates whether x and y are references to the same array. - `cmin' and `cmax' indicate which columns to compute. These are used for multithreaded evaluation. :Reference: http://en.wikipedia.org/wiki/Fractional_brownian_motion """ # Thanks to Anne Archibald for handythread.py, the model for the # multithreaded call. if h<0 or h>1: raise ValueError, 'Parameter h must be between 0 and 1.' if amp<0. or scale<0.: raise ValueError, 'The amp and scale parameters must be positive.' if symm is None: symm = (x is y) # Figure out how to divide job up between threads. nx = x.shape[0] ny = y.shape[0] n_threads = min(get_threadpool_size(), nx*ny / 10000) if n_threads > 1: if not symm: bounds = np.linspace(0,ny,n_threads+1) else: bounds = np.array(np.sqrt(np.linspace(0,ny*ny,n_threads+1)),dtype=int) # Allocate the matrix C = np.asmatrix(np.empty((nx,ny),dtype=float,order='F')) if origin is not None: x = x-origin y = y-origin x = x / float(scale) y = y / float(scale) if n_threads <= 1: brownian_targ(C,x,y,h,amp,0,-1,symm) else: thread_args=[(C,x,y,h,amp,bounds[i],bounds[i+1],symm) for i in xrange(n_threads)] map_noreturn(brownian_targ, thread_args) return C
def spear_threading(x, y, idx, idy, sigma, tau, lags, wids, scales, symm=None, set_pmap=False, blocksize=10000): """ threaded version, divide matrix into subblocks with *blocksize* elements each. Do not use it when multiprocessing is on (e.g., in emcee MCMC sampling). set_pmap needs to be turned on for the Pmap_Model. """ if (sigma < 0. or tau < 0.): raise ValueError, 'The amp and scale parameters must be positive.' if (symm is None): symm = (x is y) and (idx is idy) x = regularize_array(x) y = regularize_array(y) nx = x.shape[0] ny = y.shape[0] if np.isscalar(idx): idx = np.ones(nx, dtype="int", order="F") * idx if np.isscalar(idy): idy = np.ones(nx, dtype="int", order="F") * idy # Figure out how to divide job up between threads (along y) n_threads = min(get_threadpool_size(), nx * ny / blocksize) if n_threads > 1: if not symm: # divide ny evenly if x is not y bounds = np.linspace(0, ny, n_threads + 1) else: # divide ny*ny evenly in quadrature if x is y bounds = np.array(np.sqrt(np.linspace(0, ny * ny, n_threads + 1)), dtype=int) # Allocate the matrix C = np.asmatrix(np.empty((nx, ny), dtype=float, order='F')) if set_pmap: def targ(C, x, y, idx, idy, cmin, cmax, symm): SCF.covmatpmap_bit(C, x, y, idx, idy, sigma, tau, lags, wids, scales, cmin, cmax, symm) else: def targ(C, x, y, idx, idy, cmin, cmax, symm): SCF.covmat_bit(C, x, y, idx, idy, sigma, tau, lags, wids, scales, cmin, cmax, symm) if n_threads <= 1: targ(C, x, y, idx, idy, 0, -1, symm) else: thread_args = [(C, x, y, idx, idy, bounds[i], bounds[i + 1], symm) for i in xrange(n_threads)] map_noreturn(targ, thread_args) if symm: isotropic_cov_funs.symmetrize(C) return (C)
def __call__(self, x, y, amp=1., scale=1., symm=None, *args, **kwargs): if amp < 0. or scale < 0.: raise ValueError, 'The amp and scale parameters must be positive.' if symm is None: symm = (x is y) # Figure out how to divide job up between threads. nx = x.shape[0] ny = y.shape[0] n_threads = min(get_threadpool_size(), nx * ny / 10000) if n_threads > 1: if not symm: bounds = np.linspace(0, ny, n_threads + 1) else: bounds = np.array(np.sqrt( np.linspace(0, ny * ny, n_threads + 1)), dtype=int) # Split off the distance arguments distance_arg_dict = {} if hasattr(self.distance_fun, 'extra_parameters'): for key in self.extra_distance_params.iterkeys(): if key in kwargs.keys(): distance_arg_dict[key] = kwargs.pop(key) # Allocate the matrix C = np.asmatrix(np.empty((nx, ny), dtype=float, order='F')) def targ(C, x, y, cmin, cmax, symm, d_kwargs=distance_arg_dict, c_args=args, c_kwargs=kwargs): # Compute distance for this bit self.distance_fun(C, x, y, cmin=cmin, cmax=cmax, symm=symm, **d_kwargs) imul(C, 1. / scale, cmin=cmin, cmax=cmax, symm=symm) # Compute covariance for this bit if self.with_x: self.cov_fun(C, x, y, cmin=cmin, cmax=cmax, symm=symm, *c_args, **c_kwargs) else: self.cov_fun(C, cmin=cmin, cmax=cmax, symm=symm, *c_args, **c_kwargs) imul(C, amp * amp, cmin=cmin, cmax=cmax, symm=symm) if n_threads <= 1: targ(C, x, y, 0, -1, symm) else: thread_args = [(C, x, y, bounds[i], bounds[i + 1], symm) for i in xrange(n_threads)] map_noreturn(targ, thread_args) if symm: symmetrize(C) return C