def train_mwu_mkl(kerns, param, feat, Xtr, ytr, eps = 0.2, C = 1000.0, norm1or2 = 2, verbose = 0): """ (success, Sigma, alpha, bsvm, posw) = train_mwu_mkl( kerns, kern_params, features, Xtr, ytr, eps = 0.2, C = 1000.0, verbose = 0 ) """ (m,) = kerns.shape (d,ntr) = Xtr.shape in_kerns = np.require(kerns, dtype = np.int32, requirements = ['C']) in_param = np.require(param, dtype = np.float64, requirements = ['C']) in_feat = np.require(feat, dtype = np.int32, requirements = ['C']) in_Xtr = np.require(Xtr, dtype = np.float64, requirements = ['C']) in_ytr = np.require(ytr, dtype = np.int32, requirements = ['C']) return _train_mwu_mkl(m, ntr, ntr, in_kerns, in_param, in_feat, in_Xtr, in_ytr, d, ntr, m, eps, 1.0, 20.0, C, norm1or2, verbose)
def fc_layer(self, ld): epsB = ld['epsB'] epsW = ld['epsW'] initB = ld.get('initB', 0.0) initW = ld['initW'] momB = ld['momB'] momW = ld['momW'] wc = ld['wc'] dropRate = ld.get('dropRate', 0.0) n_out = ld['outputs'] bias = ld.get('biases', None) weight = ld.get('weights', None) if bias is not None: bias = bias.transpose() bias = np.require(bias, dtype = np.float32, requirements = 'C') if weight is not None: weight = weight.transpose() weight = np.require(weight, dtype = np.float32, requirements = 'C') name = ld['name'] input_shape = ld['inputShape'] return FCLayer(name, input_shape, n_out, epsW, epsB, initW, initB, momW = momW, momB = momB, wc = wc, dropRate = dropRate, weight = weight, bias = bias)
def cache_z(self, z): x = np.require(z.real, dtype = np.double, requirements = ['A','W','O','C']) y = np.require(z.imag, dtype = np.double, requirements = ['A','W','O','C']) xd = gpuarray.to_gpu(x) yd = gpuarray.to_gpu(y) cuda.memcpy_dtod(self.xd, xd.ptr, xd.nbytes) cuda.memcpy_dtod(self.yd, yd.ptr, yd.nbytes)
def read_wfsx(self, fname, **kw): """ An occasional reading of the SIESTA's .WFSX file """ from pyscf.nao.m_siesta_wfsx import siesta_wfsx_c from pyscf.nao.m_siesta2blanko_denvec import _siesta2blanko_denvec from pyscf.nao.m_fermi_dirac import fermi_dirac_occupations self.wfsx = siesta_wfsx_c(fname=fname, **kw) assert self.nkpoints == self.wfsx.nkpoints assert self.norbs == self.wfsx.norbs assert self.nspin == self.wfsx.nspin orb2m = self.get_orb2m() for k in range(self.nkpoints): for s in range(self.nspin): for n in range(self.norbs): _siesta2blanko_denvec(orb2m, self.wfsx.x[k,s,n,:,:]) self.mo_coeff = np.require(self.wfsx.x, dtype=self.dtype, requirements='CW') self.mo_energy = np.require(self.wfsx.ksn2e, dtype=self.dtype, requirements='CW') self.telec = kw['telec'] if 'telec' in kw else self.hsx.telec self.nelec = kw['nelec'] if 'nelec' in kw else self.hsx.nelec self.fermi_energy = kw['fermi_energy'] if 'fermi_energy' in kw else self.fermi_energy ksn2fd = fermi_dirac_occupations(self.telec, self.mo_energy, self.fermi_energy) self.mo_occ = (3-self.nspin)*ksn2fd return self
def compute_v_without_derivs(self, Xs, Yinvs, Ts): #Turn the parts of omega into gpuarrays Xs = np.require(Xs, dtype = np.double, requirements=['A', 'W', 'O', 'C']) Yinvs = np.require(Yinvs, dtype = np.double, requirements=['A', 'W', 'O', 'C']) Ts = np.require(Ts, dtype = np.double, requirements=['A', 'W', 'O', 'C']) Xs_d = gpuarray.to_gpu(Xs) Yinvs_d = gpuarray.to_gpu(Yinvs) Ts_d = gpuarray.to_gpu(Ts) #Determine N = the number of integer points to sum over # K = the number of different omegas to compute the function at N = self.Sd.size/self.g K = Xs.size/(self.g**2) #Create room on the gpu for the real and imaginary finite sum calculations fsum_reald = gpuarray.zeros(N*K, dtype=np.double) fsum_imagd = gpuarray.zeros(N*K, dtype=np.double) #Turn all scalars into numpy data types Nd = np.int32(N) Kd = np.int32(K) gd = np.int32(self.g) blocksize = (self.tilewidth, self.tileheight, 1) gridsize = (N//self.tilewidth + 1, K//self.tileheight + 1, 1) self.finite_sum_without_derivs(fsum_reald, fsum_imagd, Xs_d, Yinvs_d, Ts_d, self.Sd, gd, Nd, Kd, block = blocksize, grid = gridsize) cuda.Context.synchronize() fsums_real = self.sum_reduction(fsum_reald, N, K, Kd, Nd) fsums_imag = self.sum_reduction(fsum_imagd, N, K, Kd, Nd) return fsums_real + 1.0j*fsums_imag
def get_next_batch(self): self.advance_batch() epoch = self.curr_epoch batch_num = self.curr_batchnum tp_batch_ind = self.tp_batch_dic[batch_num] # print 'tp-info, batch_name: %d' % tp_batch_ind if self.multiview: data,labels = tp_utils.make_multiview_batch_n_labels(self.tp_dataStore,self.tp_batches[tp_batch_ind],self.tp_class_dict) else: data,labels = tp_utils.make_batch_n_labels(self.tp_dataStore,self.tp_batches[tp_batch_ind],self.tp_class_dict) data.shape # data = tp_utils.make_batch(self.tp_dataStore,self.tp_batches[tp_batch_ind]) # labels = tp_utils.make_batch_labels(self.tp_class_dict,self.tp_batches[tp_batch_ind]) #dic = {'data':data,'labels':labels} data = np.require(data,requirements='C') #tp_utils.test_data(data[:,0]) labels = np.require(labels,requirements='C') return epoch, batch_num, [data, labels]
def check_distance(self, parent_ix, coords): '''Check to ensure that the distance between the coordinates `coords` and the parent_ix is less than the distance to any other center in the parent level''' if parent_ix is None: return True try: passed_coord_dtype = coords.dtype except AttributeError: coords = np.require(coords, dtype=coord_dtype) else: if passed_coord_dtype != coord_dtype: coords = np.require(coords, dtype=coord_dtype) coords = coords.reshape((1, -1)) assert len(coords) == 1 parent_level = self.bin_graph.node[parent_ix]['level'] level_indices = self.level_indices[parent_level] parent_centers = self.fetch_centers(level_indices) mask = np.ones((1,), dtype=np.bool_) output = np.empty((1,), dtype=index_dtype) min_dist = np.empty((1,), dtype=coord_dtype) self._assign_level(coords, parent_centers, mask, output, min_dist) res = output[0] == level_indices.index(parent_ix) return res
def get_next_batch(self): epoch, batchnum, dic = LabeledDummyDataProvider.get_next_batch(self) dic['data'] = n.require(dic['data'].T, requirements='C') dic['labels'] = n.require(dic['labels'].T, requirements='C') return epoch, batchnum, [dic['data'], dic['labels']]
def setdiff_rows(A, B, return_index=False): """ Similar to MATLAB's setdiff(A, B, 'rows'), this returns C, I where C are the row of A that are not in B and I satisfies C = A[I,:]. Returns I if return_index is True. """ A = np.require(A, requirements='C') B = np.require(B, requirements='C') assert A.ndim == 2, "array must be 2-dim'l" assert B.ndim == 2, "array must be 2-dim'l" assert A.shape[1] == B.shape[1], \ "arrays must have the same number of columns" assert A.dtype == B.dtype, \ "arrays must have the same data type" # NumPy provides setdiff1d, which operates only on one dimensional # arrays. To make the array one-dimensional, we interpret each row # as being a string of characters of the appropriate length. orig_dtype = A.dtype ncolumns = A.shape[1] dtype = np.dtype((np.character, orig_dtype.itemsize*ncolumns)) C = np.setdiff1d(A.view(dtype), B.view(dtype)) \ .view(A.dtype) \ .reshape((-1, ncolumns), order='C') if return_index: raise NotImplementedError else: return C
def compute_v_without_derivs(self, Z): #Turn the numpy set Z into gpuarrays x = Z.real y = Z.imag x = np.require(x, dtype = np.double, requirements=['A','W','O','C']) y = np.require(y, dtype = np.double, requirements=['A','W','O','C']) xd = gpuarray.to_gpu(x) yd = gpuarray.to_gpu(y) self.yd = yd #Detemine N = the number of integer points to sum over and # K = the number of values to compute the function at N = self.Sd.size/self.g K = Z.size/self.g #Create room on the gpu for the real and imaginary finite sum calculations fsum_reald = gpuarray.zeros(N*K, dtype=np.double) fsum_imagd = gpuarray.zeros(N*K, dtype=np.double) #Make all scalars into numpy data types Nd = np.int32(N) Kd = np.int32(K) gd = np.int32(self.g) blocksize = (self.tilewidth, self.tileheight, 1) gridsize = (N//self.tilewidth + 1, K//self.tileheight + 1, 1) self.finite_sum_without_derivs(fsum_reald, fsum_imagd, xd, yd, self.Sd, gd, Nd, Kd, block = blocksize, grid = gridsize) cuda.Context.synchronize() fsums_real = self.sum_reduction(fsum_reald, N, K, Kd, Nd) fsums_imag = self.sum_reduction(fsum_imagd, N, K, Kd, Nd) return fsums_real + 1.0j*fsums_imag
def load_data(self, model_data, callback=None): t_start = time.time() vertices, normals = model_data # convert python lists to numpy arrays for constructing vbos self.vertices = numpy.require(vertices, 'f') self.normals = numpy.require(normals, 'f') self.scaling_factor = 1.0 self.rotation_angle = { self.AXIS_X: 0.0, self.AXIS_Y: 0.0, self.AXIS_Z: 0.0, } self.mat_specular = (1.0, 1.0, 1.0, 1.0) self.mat_shininess = 50.0 self.light_position = (20.0, 20.0, 20.0) self.initialized = False t_end = time.time() logging.info('Initialized STL model in %.2f seconds' % (t_end - t_start)) logging.info('Vertex count: %d' % len(self.vertices))
def autocorr_fft(signal, axis = -1): """Return full autocorrelation along specified axis. Use fft for computation.""" if N.ndim(signal) == 0: return signal elif signal.ndim == 1: n = signal.shape[0] nfft = int(2 ** nextpow2(2 * n - 1)) lag = n - 1 a = fft(signal, n = nfft, axis = -1) au = ifft(a * N.conj(a), n = nfft, axis = -1) return N.require(N.concatenate((au[-lag:], au[:lag+1])), dtype = signal.dtype) elif signal.ndim == 2: n = signal.shape[axis] lag = n - 1 nfft = int(2 ** nextpow2(2 * n - 1)) a = fft(signal, n = nfft, axis = axis) au = ifft(a * N.conj(a), n = nfft, axis = axis) if axis == 0: return N.require(N.concatenate( (au[-lag:], au[:lag+1]), axis = axis), \ dtype = signal.dtype) else: return N.require(N.concatenate( (au[:, -lag:], au[:, :lag+1]), axis = axis), dtype = signal.dtype) else: raise RuntimeError("rank >2 not supported yet")
def bench(): size = 256 nframes = 4000 lag = 24 X = N.random.randn(nframes, size) X = N.require(X, requirements = 'C') niter = 10 # Contiguous print "Running optimized with ctypes" def contig(*args, **kargs): return autocorr_oneside_nofft(*args, **kargs) for i in range(niter): Yt = contig(X, lag, axis = 1) Yr = _autocorr_oneside_nofft_py(X, lag, axis = 1) N.testing.assert_array_almost_equal(Yt, Yr, 10) # Non contiguous print "Running optimized with ctypes (non contiguous)" def ncontig(*args, **kargs): return autocorr_oneside_nofft(*args, **kargs) X = N.require(X, requirements = 'F') for i in range(niter): Yt = ncontig(X, lag, axis = 1) Yr = _autocorr_oneside_nofft_py(X, lag, axis = 1) N.testing.assert_array_almost_equal(Yt, Yr, 10) print "Benchmark func done"
def comp_apair_pp_libint(self, a1,a2): """ Get's the vertex coefficient and conversion coefficients for a pair of atoms given by their atom indices """ from operator import mul from pyscf.nao.m_prod_biloc import prod_biloc_c if not hasattr(self, 'sv_pbloc_data') : raise RuntimeError('.sv_pbloc_data is absent') assert a1>=0 assert a2>=0 t1 = timer() sv = self.sv aos = self.sv.ao_log sp12 = np.require( np.array([sv.atom2sp[a] for a in (a1,a2)], dtype=c_int64), requirements='C') rc12 = np.require( np.array([sv.atom2coord[a,:] for a in (a1,a2)]), requirements='C') icc2a = np.require( np.array(self.ls_contributing(a1,a2), dtype=c_int64), requirements='C') npmx = aos.sp2norbs[sv.atom2sp[a1]]*aos.sp2norbs[sv.atom2sp[a2]] npac = sum([self.prod_log.sp2norbs[sv.atom2sp[ia]] for ia in icc2a ]) nout = c_int64(npmx**2+npmx*npac+10) dout = np.require( zeros(nout.value), requirements='CW') libnao.vrtx_cc_apair( sp12.ctypes.data_as(POINTER(c_int64)), rc12.ctypes.data_as(POINTER(c_double)), icc2a.ctypes.data_as(POINTER(c_int64)), c_int64(len(icc2a)), dout.ctypes.data_as(POINTER(c_double)), nout ) if dout[0]<1: return None nnn = np.array(dout[0:3], dtype=int) nnc = np.array([dout[8],dout[7]], dtype=int) ncc = int(dout[9]) if ncc!=len(icc2a): raise RuntimeError('ncc!=len(icc2a)') s = 10; f=s+np.prod(nnn); vrtx = dout[s:f].reshape(nnn) s = f; f=s+np.prod(nnc); ccoe = dout[s:f].reshape(nnc) icc2s = np.zeros(len(icc2a)+1, dtype=np.int64) for icc,a in enumerate(icc2a): icc2s[icc+1] = icc2s[icc] + self.prod_log.sp2norbs[sv.atom2sp[a]] pbiloc = prod_biloc_c(atoms=array([a2,a1]),vrtx=vrtx,cc2a=icc2a,cc2s=icc2s,cc=ccoe) return pbiloc
def get_next_batch(self): self.advance_batch() epoch = self.curr_epoch batchnum = self.curr_batchnum datadic = leveldb.LevelDB(self.data_dir + '/batch-%d' % batchnum) img_raw = [] label_raw = [] for k, pickled in datadic.RangeIter(): imgdata = cPickle.loads(pickled) img_raw.append(Image.open(c.StringIO(imgdata['data']))) label_raw.append(imgdata['label']) labels = n.array(label_raw) images = n.ndarray((len(img_raw), 64 * 64 * 3), dtype=n.single) for idx, jpegdata in enumerate(img_raw): images[idx] = n.array(img_raw) print labels.shape print images.shape images = n.require(images, dtype=n.single, requirements='C') labels = labels.reshape((1, images.shape[1])) labels = n.require(labels, dtype=n.single, requirements='C') return epoch, batchnum, [images, labels]
def _ellipsoidLineIntersects_ne(a, b, lineOrigin, lineDirection, directed=True): lineOrigin = np.require(lineOrigin, dtype=np.float64) lineDirection = np.require(lineDirection, dtype=np.float64) # turn into column vectors direction = lineDirection.T origin = -lineOrigin[:,None] radius = np.array([[1/a], [1/a], [1/b]]) directionTimesRadius = ne('direction * radius') originTimesRadius = ne('origin * radius') dirDotOri = np.einsum("ij,ij->j", directionTimesRadius, originTimesRadius) dirDotDir = np.einsum("ij,ij->j", directionTimesRadius, directionTimesRadius) oriDotOri = np.einsum("ij,ij->j", originTimesRadius, originTimesRadius) if directed: if _isInsideEllipsoid(lineOrigin, a, b): intersects = ne('dirDotOri + sqrt(dirDotOri**2 - oriDotOri*dirDotDir + dirDotDir) >= 0') else: intersects = ne('dirDotOri - sqrt(dirDotOri**2 - oriDotOri*dirDotDir + dirDotDir) >= 0') else: intersects = ne('dirDotOri**2 - oriDotOri*dirDotDir + dirDotDir >= 0') return intersects
def get_next_batch(self): epoch, batchnum, d = LabeledDataProvider.get_next_batch(self) #print(datadic) # This converts the data matrix to single precision and makes sure that it is C-ordered d['data'] = n.require((d['data'].transpose()), dtype=n.single, requirements='C') d['labels'] = n.require(d['labels'].reshape((1, d['data'].shape[1])), dtype=n.single, requirements='C') return epoch, batchnum, [d['data'], d['labels']]
def sample(self, **kwargs): returnLC = self.lcObj.copy() probVal = kwargs.get('probability', 1.0) sampleSeedVal = kwargs.get('sampleSeed', rand.rdrand(np.array([0], dtype='uint32'))) np.random.seed(seed=sampleSeedVal) keepArray = spstats.bernoulli.rvs(probVal, size=self.lcObj.numCadences) newNumCadences = np.sum(keepArray) tNew = np.require(np.zeros(newNumCadences), requirements=['F', 'A', 'W', 'O', 'E']) xNew = np.require(np.zeros(newNumCadences), requirements=['F', 'A', 'W', 'O', 'E']) yNew = np.require(np.zeros(newNumCadences), requirements=['F', 'A', 'W', 'O', 'E']) yerrNew = np.require(np.zeros(newNumCadences), requirements=['F', 'A', 'W', 'O', 'E']) maskNew = np.require(np.zeros(newNumCadences), requirements=['F', 'A', 'W', 'O', 'E']) counter = 0 for i in xrange(self.lcObj.numCadences): if keepArray[i] == 1: tNew[counter] = self.lcObj.t[i] xNew[counter] = self.lcObj.x[i] yNew[counter] = self.lcObj.y[i] yerrNew[counter] = self.lcObj.yerr[i] maskNew[counter] = self.lcObj.mask[i] counter += 1 returnLC.t = tNew returnLC.x = xNew returnLC.y = yNew returnLC.yerr = yerrNew returnLC.mask = maskNew returnLC._numCadences = newNumCadences returnLC._checkIsRegular() returnLC._times() returnLC._statistics() return returnLC
def actionAngleStaeckel_calcu0(E,Lz,pot,delta): """ NAME: actionAngleStaeckel_calcu0 PURPOSE: Use C to calculate u0 in the Staeckel approximation INPUT: E, Lz - energy and angular momentum pot - Potential or list of such instances delta - focal length of prolate spheroidal coordinates OUTPUT: (u0,err) u0 : array, shape (len(E)) err - non-zero if error occured HISTORY: 2012-12-03 - Written - Bovy (IAS) """ #Parse the potential npot, pot_type, pot_args= _parse_pot(pot,potforactions=True) #Set up result arrays u0= numpy.empty(len(E)) err= ctypes.c_int(0) #Set up the C code ndarrayFlags= ('C_CONTIGUOUS','WRITEABLE') actionAngleStaeckel_actionsFunc= _lib.calcu0 actionAngleStaeckel_actionsFunc.argtypes= [ctypes.c_int, ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ctypes.c_int, ndpointer(dtype=numpy.int32,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ctypes.c_double, ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ctypes.POINTER(ctypes.c_int)] #Array requirements, first store old order f_cont= [E.flags['F_CONTIGUOUS'], Lz.flags['F_CONTIGUOUS']] E= numpy.require(E,dtype=numpy.float64,requirements=['C','W']) Lz= numpy.require(Lz,dtype=numpy.float64,requirements=['C','W']) u0= numpy.require(u0,dtype=numpy.float64,requirements=['C','W']) #Run the C code actionAngleStaeckel_actionsFunc(len(E), E, Lz, ctypes.c_int(npot), pot_type, pot_args, ctypes.c_double(delta), u0, ctypes.byref(err)) #Reset input arrays if f_cont[0]: E= numpy.asfortranarray(E) if f_cont[1]: Lz= numpy.asfortranarray(Lz) return (u0,err.value)
def sample(self, **kwargs): returnLC = self.lcObj.copy() widthVal = kwargs.get('width', returnLC.T/10.0) centerVal = kwargs.get('center', returnLC.T/2.0) sampleSeedVal = kwargs.get('sampleSeed', rand.rdrand(np.array([0], dtype='uint32'))) np.random.seed(seed=sampleSeedVal) del returnLC.t del returnLC.x del returnLC.y del returnLC.yerr del returnLC.mask tList = list() xList = list() yList = list() yerrList = list() maskList = list() for i in xrange(self.lcObj.numCadences): keepYN = np.random.binomial(1, self.normalizedSincSq(widthVal, centerVal, self.lcObj.t[i])) if keepYN == 1: tList.append(self.lcObj.t[i]) xList.append(self.lcObj.x[i]) yList.append(self.lcObj.y[i]) yerrList.append(self.lcObj.yerr[i]) maskList.append(self.lcObj.mask[i]) newNumCadences = len(tList) returnLC.t = np.require(np.array(tList), requirements=['F', 'A', 'W', 'O', 'E']) returnLC.x = np.require(np.array(xList), requirements=['F', 'A', 'W', 'O', 'E']) returnLC.y = np.require(np.array(yList), requirements=['F', 'A', 'W', 'O', 'E']) returnLC.yerr = np.require(np.array(yerrList), requirements=['F', 'A', 'W', 'O', 'E']) returnLC.mask = np.require(np.array(maskList), requirements=['F', 'A', 'W', 'O', 'E']) returnLC._numCadences = newNumCadences returnLC._checkIsRegular() returnLC._times() returnLC._statistics() return returnLC
def sample(self, **kwargs): returnLC = self.lcObj.copy() jumpVal = kwargs.get('jump', 1) newNumCadences = int(self.lcObj.numCadences/float(jumpVal)) tNew = np.require(np.zeros(newNumCadences), requirements=['F', 'A', 'W', 'O', 'E']) xNew = np.require(np.zeros(newNumCadences), requirements=['F', 'A', 'W', 'O', 'E']) yNew = np.require(np.zeros(newNumCadences), requirements=['F', 'A', 'W', 'O', 'E']) yerrNew = np.require(np.zeros(newNumCadences), requirements=['F', 'A', 'W', 'O', 'E']) maskNew = np.require(np.zeros(newNumCadences), requirements=['F', 'A', 'W', 'O', 'E']) for i in xrange(newNumCadences): tNew[i] = self.lcObj.t[jumpVal*i] xNew[i] = self.lcObj.x[jumpVal*i] yNew[i] = self.lcObj.y[jumpVal*i] yerrNew[i] = self.lcObj.yerr[jumpVal*i] maskNew[i] = self.lcObj.mask[jumpVal*i] returnLC.t = tNew returnLC.x = xNew returnLC.y = yNew returnLC.yerr = yerrNew returnLC.mask = maskNew returnLC._numCadences = newNumCadences returnLC._checkIsRegular() returnLC._times() returnLC._statistics() return returnLC
def slit_uniform_psf(n, seeing, mu_x, mu_y, tau_0, slit_width, slit_height, plot=False): """Returns x- and y- coordinate arrays of a 2D random uniformly distributed circle. Parameters ---------- n : int Size of coordinate arrays. seeing: double Seeing of source psf in arcseconds. mu_x : double Center of PSF in x-coords. mu_y : double Center of PSF in y-coords. tau_0 : double Rotation about z-axis (tilt). slit_width : double Width of slit in arcseconds. slit_height : double Height of slit in arcseconds. Returns ------- slit_x : array_like Array of x-coordinates. slit_y : array_like Array of y-coordinates. """ desc = "Source psf: uniform, mux=%.2f muy=%.2f seeing=%.2f arcsec" % (mu_x, mu_y, seeing) log.info(desc) # initialize output arrays to send to c function slit_x = np.empty(n, dtype=np.float64) slit_y = np.empty(n, dtype=np.float64) slit_x = np.require(slit_x, requirements=ci.req_out, dtype=np.float64) slit_y = np.require(slit_y, requirements=ci.req_out, dtype=np.float64) func = ci.slitc.slit_uniform_psf func.argtypes = [ ct.c_int, # n ct.c_double, # seeing ct.c_double, # mu_x ct.c_double, # mu_y ct.c_double, # tau_0 ct.c_double, # slit_width ct.c_double, # slit_height ci.array_1d_double, # slit_x ci.array_1d_double] # slit_y func.restype = None log.info("Slit Rejection Sampling: %s rays...", n) func(n, seeing, mu_x, mu_y, tau_0, slit_width, slit_height, slit_x, slit_y) # preview slit if plot: log.info("Opening preview plot of 2D uniformly random psf.") import matplotlib.pylab as plt fig = plt.figure() ax = fig.add_subplot(111)#, aspect='equal') ax.scatter(slit_x, slit_y, s=20, edgecolor=None) plt.title("0D Point Source PSF") plt.show() return slit_x, slit_y
def make_predictions(net, data, labels, num_classes): data = np.require(data, requirements='C') labels = np.require(labels, requirements='C') preds = np.zeros((data.shape[1], num_classes), dtype=np.single) softmax_idx = net.get_layer_idx('probs', check_type='softmax') t0 = time.time() net.libmodel.startFeatureWriter( [data, labels, preds], softmax_idx) net.finish_batch() print "Predicted %s cases in %.2f seconds." % ( labels.shape[1], time.time() - t0) if net.multiview_test: # We have to deal with num_samples * num_views # predictions. num_views = net.test_data_provider.num_views num_samples = labels.shape[1] / num_views split_sections = range( num_samples, num_samples * num_views, num_samples) preds = np.split(preds, split_sections, axis=0) labels = np.split(labels, split_sections, axis=1) preds = reduce(np.add, preds) labels = labels[0] return preds, labels
def _lpc2_py(signal, order, axis = -1): """python implementation of lpc for rank 2., Do not use, for testing purpose only""" if signal.ndim > 2: raise NotImplemented("only for rank <=2") if signal.ndim < 2: return lpc(_N.require(signal, requirements = 'C'), order) # For each array of direction axis, compute levinson durbin if axis % 2 == 0: # Prepare output arrays coeff = _N.zeros((order+1, signal.shape[1]), signal.dtype) kcoeff = _N.zeros((order, signal.shape[1]), signal.dtype) err = _N.zeros(signal.shape[1], signal.dtype) for i in range(signal.shape[1]): coeff[:, i], err[i], kcoeff[:, i] = \ lpc(_N.require(signal[:, i], requirements = 'C'), order) elif axis % 2 == 1: # Prepare output arrays coeff = _N.zeros((signal.shape[0], order+1), signal.dtype) kcoeff = _N.zeros((signal.shape[0], order), signal.dtype) err = _N.zeros(signal.shape[0], signal.dtype) for i in range(signal.shape[0]): coeff[i], err[i], kcoeff[i] = \ lpc(_N.require(signal[i], requirements = 'C'), order) else: raise RuntimeError("this should not happen, please fill a bug") return coeff, err, kcoeff
def lagrange_interpol_2D_td(points1, points2, coefficients, x1, x2): points1 = np.require(points1, dtype=np.float64, requirements=["F_CONTIGUOUS"]) points2 = np.require(points2, dtype=np.float64, requirements=["F_CONTIGUOUS"]) coefficients = np.require(coefficients, dtype=np.float64, requirements=["F_CONTIGUOUS"]) # Should be safe enough. This was never raised while extracting a lot of # seismograms. assert len(points1) == len(points2) N = len(points1) - 1 nsamp = coefficients.shape[0] interpolant = np.zeros(nsamp, dtype="float64", order="F") lib.lagrange_interpol_2D_td( C.c_int(N), C.c_int(nsamp), points1.ctypes.data_as(C.POINTER(C.c_double)), points2.ctypes.data_as(C.POINTER(C.c_double)), coefficients.ctypes.data_as(C.POINTER(C.c_double)), C.c_double(x1), C.c_double(x2), interpolant.ctypes.data_as(C.POINTER(C.c_double))) return interpolant
def get_next_batch(self): self.get_next_index() epoch = self.curr_epoch filename = os.path.join(self.data_dir, 'data_batch_%d' % (self.curr_batch)) start = time.time() if os.path.isdir(filename): images = [] labels = [] for sub_filename in os.listdir(filename): path = os.path.join(filename, sub_filename) data = util.load(path) images.extend(data['data']) labels.extend(data['labels']) data['data'] = images data['labels'] = labels else: data = util.load(filename) data = self.__multigpu_seg(data) images = data['data'] cropped = np.ndarray((3, self.inner_size, self.inner_size, len(images) * self.num_view), dtype = np.float32) self.__decode_trim_images2(images, cropped) cropped = garray.reshape_last(cropped) - self.data_mean cropped = np.require(cropped.reshape((3, self.inner_size, self.inner_size, len(images) * self.num_view)), dtype = np.single, requirements='C') labels = np.array(labels) labels = labels.reshape(labels.size, ) labels = np.require(labels, dtype=np.single, requirements='C') return BatchData(cropped, labels, epoch)
def print_predictions(self): data = self.get_next_batch(train=False)[2] # get a test batch num_classes = self.test_data_provider.get_num_classes() softmax_idx = self.get_layer_idx('probs', check_type='softmax') NUM_IMGS = 1 NUM_TOP_CLASSES = min(num_classes, 4) # show this many top labels label_names = self.test_data_provider.batch_meta['label_names'] preds = n.zeros((NUM_IMGS, num_classes), dtype=n.single) rand_idx = nr.randint(0, data[0].shape[1], NUM_IMGS) data[0] = n.require(data[0][:,rand_idx], requirements='C') data[1] = n.require(data[1][:,rand_idx], requirements='C') data += [preds] # Run the model self.libmodel.startFeatureWriter(data, softmax_idx) self.finish_batch() data[0] = self.test_data_provider.get_plottable_data(data[0]) img_idx = 0 true_label = int(data[1][0,img_idx]) img_labels = sorted(zip(preds[img_idx,:], label_names), key=lambda x: x[0])[-NUM_TOP_CLASSES:] print "true_label=%s" % (label_names[true_label]) for l in img_labels: print "l=%s" % (str(l)) binary_checkpoint_file = "binary_%d.%d.ntwk" % (self.epoch, self.batchnum) self.save_as_binary(binary_checkpoint_file)
def __init__(self, data_dir, img_size, num_colors, # options i've add to cifar data provider batch_range=None, init_epoch=1, init_batchnum=None, dp_params=None, test=False): LabeledMemoryDataProvider.__init__(self, data_dir, batch_range, init_epoch, init_batchnum, dp_params, test) self.num_colors = num_colors self.img_size = img_size self.border_size = dp_params['crop_border'] self.inner_size = self.img_size - self.border_size*2 self.multiview = dp_params['multiview_test'] and test self.img_flip = dp_params['img_flip'] if self.img_flip: self.num_views = 5*2 else : self.num_views = 5; self.data_mult = self.num_views if self.multiview else 1 for d in self.data_dic: d['data'] = n.require(d['data'], requirements='C') d['labels'] = n.require(n.tile(d['labels'].reshape((1, d['data'].shape[1])), (1, self.data_mult)), requirements='C') self.cropped_data = [n.zeros((self.get_data_dims(), self.data_dic[0]['data'].shape[1]*self.data_mult), dtype=n.single) for x in xrange(2)] self.batches_generated = 0 self.data_mean = self.batch_meta['data_mean'].reshape((self.num_colors,self.img_size,self.img_size))[:,self.border_size:self.border_size+self.inner_size,self.border_size:self.border_size+self.inner_size].reshape((self.get_data_dims(), 1))
def get_next_batch(self): self.get_next_index() epoch = self.curr_epoch batchnum = self.curr_batch names = self.images[self.batches[batchnum]] num_imgs = len(names) labels = np.zeros(len(names)) cropped = np.ndarray((3, self.inner_size, self.inner_size, num_imgs * self.num_view), dtype=np.float32) self.__decode_trim_images2(names, cropped) clabel = [] # extract label from the filename for idx, filename in enumerate(names): filename = os.path.basename(filename) synid = filename[1:].split('_')[0] label = self.batch_meta['synid_to_label'][synid] labels[idx] = label cropped = np.require(cropped, dtype=np.single, requirements='C') old_shape = cropped.shape cropped = garray.reshape_last(cropped) - self.data_mean cropped = cropped.reshape(old_shape) labels = np.array(labels) labels = labels.reshape(labels.size,) labels = np.require(labels, dtype=np.single, requirements='C') #util.log_info('get one batch %f', time.time() - start) return BatchData(cropped, labels, epoch)
def sample(self, **kwargs): returnLC = self.lcObj.copy() timeStamps = kwargs.get('timestamps', None) timeStampDeltas = timeStamps[1:] - timeStamps[:-1] SDSSLength = timeStamps[-1] - timeStamps[0] minDelta = np.min(timeStampDeltas) if minDelta < self.lcObj.dt: raise ValueError('Insufficiently dense sampling!') if SDSSLength > self.lcObj.T: raise ValueError('Insufficiently long lc!') newNumCadences = timeStamps.shape[0] tNew = np.require(np.zeros(newNumCadences), requirements=['F', 'A', 'W', 'O', 'E']) xNew = np.require(np.zeros(newNumCadences), requirements=['F', 'A', 'W', 'O', 'E']) yNew = np.require(np.zeros(newNumCadences), requirements=['F', 'A', 'W', 'O', 'E']) yerrNew = np.require(np.zeros(newNumCadences), requirements=['F', 'A', 'W', 'O', 'E']) maskNew = np.require(np.zeros(newNumCadences), requirements=['F', 'A', 'W', 'O', 'E']) for i in xrange(newNumCadences): index = np.where(self.lcObj.t > timeStamps[i])[0][0] tNew[i] = self.lcObj.t[index] xNew[i] = self.lcObj.x[index] yNew[i] = self.lcObj.y[index] yerrNew[i] = self.lcObj.yerr[index] maskNew[i] = self.lcObj.mask[index] returnLC.t = tNew returnLC.x = xNew returnLC.y = yNew returnLC.yerr = yerrNew returnLC.mask = maskNew returnLC._numCadences = newNumCadences returnLC._checkIsRegular() returnLC._times() returnLC._statistics() return returnLC
def initialize_simulation(self, basis_states, target_states, segs_per_state=1, suppress_we=False): '''Initialize a new weighted ensemble simulation, taking ``segs_per_state`` initial states from each of the given ``basis_states``. ``w_init`` is the forward-facing version of this function''' data_manager = self.data_manager work_manager = self.work_manager pstatus = self.rc.pstatus system = self.system pstatus('Creating HDF5 file {!r}'.format( self.data_manager.we_h5filename)) data_manager.prepare_backing() # Process target states data_manager.save_target_states(target_states) self.report_target_states(target_states) # Process basis states self.get_bstate_pcoords(basis_states) self.data_manager.create_ibstate_group(basis_states) self.report_basis_states(basis_states) pstatus('Preparing initial states') initial_states = [] weights = [] if self.do_gen_istates: istate_type = InitialState.ISTATE_TYPE_GENERATED else: istate_type = InitialState.ISTATE_TYPE_BASIS for basis_state in basis_states: for _iseg in range(segs_per_state): initial_state = data_manager.create_initial_states(1, 1)[0] initial_state.basis_state_id = basis_state.state_id initial_state.basis_state = basis_state initial_state.istate_type = istate_type weights.append(basis_state.probability / segs_per_state) initial_states.append(initial_state) if self.do_gen_istates: futures = [ work_manager.submit(wm_ops.gen_istate, args=(initial_state.basis_state, initial_state)) for initial_state in initial_states ] for future in work_manager.as_completed(futures): rbstate, ristate = future.get_result() initial_states[ristate.state_id].pcoord = ristate.pcoord else: for initial_state in initial_states: basis_state = initial_state.basis_state initial_state.pcoord = basis_state.pcoord initial_state.istate_status = InitialState.ISTATE_STATUS_PREPARED for initial_state in initial_states: log.debug('initial state created: {!r}'.format(initial_state)) # save list of initial states just generated # some of these may not be used, depending on how WE shakes out data_manager.update_initial_states(initial_states, n_iter=1) if not suppress_we: self.we_driver.populate_initial(initial_states, weights, system) segments = list(self.we_driver.next_iter_segments) binning = self.we_driver.next_iter_binning else: segments = list(self.we_driver.current_iter_segments) binning = self.we_driver.final_binning bin_occupancies = numpy.fromiter(map(len, binning), dtype=numpy.uint, count=self.we_driver.bin_mapper.nbins) target_occupancies = numpy.require(self.we_driver.bin_target_counts, dtype=numpy.uint) # Make sure we have for segment in segments: segment.n_iter = 1 segment.status = Segment.SEG_STATUS_PREPARED assert segment.parent_id < 0 assert initial_states[segment.initial_state_id].iter_used == 1 data_manager.prepare_iteration(1, segments) data_manager.update_initial_states(initial_states, n_iter=1) if self.rc.verbose_mode: pstatus('\nSegments generated:') for segment in segments: pstatus('{!r}'.format(segment)) pstatus(''' Total bins: {total_bins:d} Initial replicas: {init_replicas:d} in {occ_bins:d} bins, total weight = {weight:g} Total target replicas: {total_replicas:d} '''.format(total_bins=len(bin_occupancies), init_replicas=int(sum(bin_occupancies)), occ_bins=len(bin_occupancies[bin_occupancies > 0]), weight=float(sum(segment.weight for segment in segments)), total_replicas=int(sum(target_occupancies)))) # Send the segments over to the data manager to commit to disk data_manager.current_iteration = 1 # Report statistics pstatus('Simulation prepared.') self.segments = {segment.seg_id: segment for segment in segments} self.report_bin_statistics(binning, save_summary=True) data_manager.flush_backing()
def get_data(d, i): data = d.get_data(request=i)[d.sources.index('features')] # Fuel provides Cifar in uint8, convert to float32 data = numpy.require(data, dtype=numpy.float32) return data if cnorm is None else cnorm.apply(data)
#volume.SetProperty(volumeProperty) # #ren = vtk.vtkRenderer() # # #ren.AddVolume(volume) #ren.SetBackground(0, 0, 0) #ren.ResetCamera() # #renWin = vtk.vtkRenderWindow() #renWin.AddRenderer(ren) #iren = vtk.vtkRenderWindowInteractor() #iren.SetRenderWindow(renWin) #renWin.Render() #iren.Start() b = np.require(a, dtype=np.uint8) b_string = b.tostring() data_importer = vtk.vtkImageImport() data_importer.CopyImportVoidPointer(b_string, len(b_string)) data_importer.SetDataScalarTypeToUnsignedChar() data_importer.SetNumberOfScalarComponents(1) data_importer.SetDataExtent(0, 511, 0, 511, 0, 511) data_importer.SetWholeExtent(0, 511, 0, 511, 0, 511) alphaChannelFunc = vtk.vtkPiecewiseFunction() alphaChannelFunc.AddPoint(0, 0.0) alphaChannelFunc.AddPoint(64, 0.3) alphaChannelFunc.AddPoint(128, 0.5) alphaChannelFunc.AddPoint(200, 0.7) colorFunc = vtk.vtkPiecewiseFunction()
# coding=utf-8 import numpy as np from load_data import load_data import caffe (X_train,Y_train)=load_data() X_train = np.require(X_train,requirements='C') Y_train = np.require(Y_train,requirements='C') #m0=np.mean(X_train[:,0,:,:]) #m1=np.mean(X_train[:,1,:,:]) #m2=np.mean(X_train[:,2,:,:]) #print(np.shape(X_train))#(1000L, 3L, 224L, 224L) #print(np.shape(Y_train))#(1000L, 2L) #print(m0) #print(m1) #print(m2) solver = caffe.SGDSolver('solver_mid_cid_clf.prototxt') solver.net.copy_from('bvlc_alexnet.caffemodel') solver.net.set_input_arrays(X_train, Y_train) solver.test_nets[0].set_input_arrays(X_train, Y_train) for i in range(2): solver.step(1) #solver.step(40)#average_loss=40 #solver.net.save(r'D:\xinjian\test')
def require_numpy_array_layout(value): if isinstance(value, tuple): return tuple(require_numpy_array_layout(x) for x in value) else: return np.require(value, requirements=['C', 'A'])
def rand_choice(probs, choose_from=None): probs = numpy.require(probs, dtype='float32') probs /= probs.sum() if choose_from is None: choose_from = range(len(probs)) return numpy.random.choice(choose_from, 1, p=probs)[0]
def compute(self): data_in = self.getData('in') kind = self.getVal('interpolation-mode') self.dimm = data_in.shape self.ndim = data_in.ndim data_out = data_in.copy() if self.getVal('compute'): if kind in ('linear', 'nearest'): for i in range(self.ndim): val = self.getVal(self.dim_base_name + str(i) + ']') interpnew = val['length'] axisnew = self.dimm[i] x = np.linspace(0, axisnew - 1, axisnew) xnew = np.linspace(0, axisnew - 1, interpnew) if axisnew == 1: reps = np.ones((self.ndim, )) reps[i] = interpnew ynew = np.tile(data_out, reps) elif axisnew == interpnew: continue else: yinterp = interpolate.interp1d(x, data_out, kind=kind, axis=i) ynew = yinterp(xnew) data_out = ynew elif kind in ('zero', 'slinear', 'quadratic', 'cubic'): from scipy.ndimage.interpolation import map_coordinates orders = {'zero': 0, 'slinear': 1, 'quadratic': 2, 'cubic': 3} o = orders[kind] # if the data is complex, interp real and imaginary separately if data_in.dtype in (np.complex64, np.complex128): data_real = np.real(data_in) data_imag = np.imag(data_in) else: data_real = data_in data_imag = None new_dims = [] for i in range(self.ndim): val = self.getVal(self.dim_base_name + str(i) + ']') new_dims.append( np.linspace(0, val['in_len'] - 1, val['length'])) coords = np.meshgrid(*new_dims, indexing='ij') data_out = map_coordinates(data_real, coords, order=o) if data_imag is not None: data_out = ( data_out + 1j * map_coordinates(data_imag, coords, order=o)) else: # use zero-padding and FFTW to sinc-interpolate import core.math.fft as ft data_in_c64 = np.require(data_in, dtype=np.complex64, requirements='C') old_dims = np.asarray(self.dimm[::-1], dtype=np.int64) new_dims = old_dims.copy() fftargs = {} win = np.ones(data_in.shape) scale = 1 for i in range(self.ndim): val = self.getVal(self.dim_base_name + str(i) + ']') new_dims[self.ndim - i - 1] = np.int64(val['length']) if val['length'] == val['in_len']: fftargs['dim{}'.format(self.ndim - i)] = 0 else: win *= self.window(i) fftargs['dim{}'.format(self.ndim - i)] = 1 scale *= val['length'] / val['in_len'] # forward FFT with original dimensions fftargs['dir'] = 0 data_out = ft.fftw(data_in_c64, old_dims, **fftargs) data_out *= win.astype(np.complex64) # inverse FFT with new dimensions (zero-pad kspace) fftargs['dir'] = 1 data_out = ft.fftw(data_out, new_dims, **fftargs) if data_in.dtype in (np.float32, np.float64): data_out = np.real(data_out) # data needs to be scaled since we changed the size between the # forward and inverse FT data_out *= scale self.setData('out', data_out) else: pass return (0)
valid_x, valid_y = valid_set test_x, test_y = test_set print train_x.shape, train_y.shape print valid_x.shape, valid_y.shape print test_x.shape, test_y.shape batch_size = 50 learning_rate = 0.001 input_x = train_x[0:batch_size] print input_x.shape image = input_x.reshape([batch_size, 28, 28, 1]) print image.shape k = map(lambda x: x.reshape(28, 28, 1), input_x) image = np.require(k) print image.shape conv1 = Convolution((batch_size, 28, 28, 1), (5, 5, 20)) relu1 = ReLU([batch_size, 24, 24, 20]) pool1 = Pooling([batch_size, 24, 24, 20], (2, 2), stride=2) conv2 = Convolution((batch_size, 12, 12, 20), (5, 5, 32)) relu2 = ReLU([batch_size, 8, 8, 32]) pool2 = Pooling([batch_size, 8, 8, 32], (2, 2), stride=2) mlp = MLP(batch_size, learning_rate) for epoch in range(200): for i in range(train_x.shape[0] // batch_size): input_X = train_x[i * batch_size:(i + 1) * batch_size, :]
def actionAngleTorus_xvFreqs_c(pot, jr, jphi, jz, angler, anglephi, anglez, tol=0.003): """ NAME: actionAngleTorus_xvFreqs_c PURPOSE: compute configuration (x,v) and frequencies of a set of angles on a single torus INPUT: pot - Potential object or list thereof jr - radial action (scalar) jphi - azimuthal action (scalar) jz - vertical action (scalar) angler - radial angle (array [N]) anglephi - azimuthal angle (array [N]) anglez - vertical angle (array [N]) tol= (0.003) goal for |dJ|/|J| along the torus OUTPUT: (R,vR,vT,z,vz,phi,Omegar,Omegaphi,Omegaz,flag) HISTORY: 2015-08-05/07 - Written - Bovy (UofT) """ #Parse the potential from ..orbit.integrateFullOrbit import _parse_pot npot, pot_type, pot_args = _parse_pot(pot, potfortorus=True) #Set up result arrays R = numpy.empty(len(angler)) vR = numpy.empty(len(angler)) vT = numpy.empty(len(angler)) z = numpy.empty(len(angler)) vz = numpy.empty(len(angler)) phi = numpy.empty(len(angler)) Omegar = numpy.empty(1) Omegaphi = numpy.empty(1) Omegaz = numpy.empty(1) flag = ctypes.c_int(0) #Set up the C code ndarrayFlags = ('C_CONTIGUOUS', 'WRITEABLE') actionAngleTorus_xvFreqsFunc = _lib.actionAngleTorus_xvFreqs actionAngleTorus_xvFreqsFunc.argtypes=\ [ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.c_int, ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ctypes.c_int, ndpointer(dtype=numpy.int32,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ctypes.c_double, ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ctypes.POINTER(ctypes.c_int)] #Array requirements, first store old order f_cont = [ angler.flags['F_CONTIGUOUS'], anglephi.flags['F_CONTIGUOUS'], anglez.flags['F_CONTIGUOUS'] ] angler = numpy.require(angler, dtype=numpy.float64, requirements=['C', 'W']) anglephi = numpy.require(anglephi, dtype=numpy.float64, requirements=['C', 'W']) anglez = numpy.require(anglez, dtype=numpy.float64, requirements=['C', 'W']) R = numpy.require(R, dtype=numpy.float64, requirements=['C', 'W']) vR = numpy.require(vR, dtype=numpy.float64, requirements=['C', 'W']) vT = numpy.require(vT, dtype=numpy.float64, requirements=['C', 'W']) z = numpy.require(z, dtype=numpy.float64, requirements=['C', 'W']) vz = numpy.require(vz, dtype=numpy.float64, requirements=['C', 'W']) phi = numpy.require(phi, dtype=numpy.float64, requirements=['C', 'W']) Omegar = numpy.require(Omegar, dtype=numpy.float64, requirements=['C', 'W']) Omegaphi = numpy.require(Omegaphi, dtype=numpy.float64, requirements=['C', 'W']) Omegaz = numpy.require(Omegaz, dtype=numpy.float64, requirements=['C', 'W']) #Run the C code actionAngleTorus_xvFreqsFunc(ctypes.c_double(jr), ctypes.c_double(jphi), ctypes.c_double(jz), ctypes.c_int(len(angler)), angler, anglephi, anglez, ctypes.c_int(npot), pot_type, pot_args, ctypes.c_double(tol), R, vR, vT, z, vz, phi, Omegar, Omegaphi, Omegaz, ctypes.byref(flag)) #Reset input arrays if f_cont[0]: angler = numpy.asfortranarray(angler) if f_cont[1]: anglephi = numpy.asfortranarray(anglephi) if f_cont[2]: anglez = numpy.asfortranarray(anglez) return (R, vR, vT, z, vz, phi, Omegar[0], Omegaphi[0], Omegaz[0], flag.value)
def showpoints(xyz, c_gt=None, c_pred=None, waittime=0, showrot=False, magnifyBlue=0, freezerot=False, background=(0, 0, 0), normalizecolor=True, ballradius=10): global showsz, mousex, mousey, zoom, changed xyz = xyz - xyz.mean(axis=0) radius = ((xyz**2).sum(axis=-1)**0.5).max() xyz /= (radius * 2.2) / showsz if c_gt is None: c0 = np.zeros((len(xyz), ), dtype='float32') + 255 c1 = np.zeros((len(xyz), ), dtype='float32') + 255 c2 = np.zeros((len(xyz), ), dtype='float32') + 255 else: c0 = c_gt[:, 0] c1 = c_gt[:, 1] c2 = c_gt[:, 2] if normalizecolor: c0 /= (c0.max() + 1e-14) / 255.0 c1 /= (c1.max() + 1e-14) / 255.0 c2 /= (c2.max() + 1e-14) / 255.0 c0 = np.require(c0, 'float32', 'C') c1 = np.require(c1, 'float32', 'C') c2 = np.require(c2, 'float32', 'C') show = np.zeros((showsz, showsz, 3), dtype='uint8') def render(): rotmat = np.eye(3) if not freezerot: xangle = (mousey - 0.5) * np.pi * 1.2 else: xangle = 0 rotmat = rotmat.dot( np.array([ [1.0, 0.0, 0.0], [0.0, np.cos(xangle), -np.sin(xangle)], [0.0, np.sin(xangle), np.cos(xangle)], ])) if not freezerot: yangle = (mousex - 0.5) * np.pi * 1.2 else: yangle = 0 rotmat = rotmat.dot( np.array([ [np.cos(yangle), 0.0, -np.sin(yangle)], [0.0, 1.0, 0.0], [np.sin(yangle), 0.0, np.cos(yangle)], ])) rotmat *= zoom nxyz = xyz.dot(rotmat) + [showsz / 2, showsz / 2, 0] ixyz = nxyz.astype('int32') show[:] = background dll.render_ball(ct.c_int(show.shape[0]), ct.c_int(show.shape[1]), show.ctypes.data_as(ct.c_void_p), ct.c_int(ixyz.shape[0]), ixyz.ctypes.data_as(ct.c_void_p), c0.ctypes.data_as(ct.c_void_p), c1.ctypes.data_as(ct.c_void_p), c2.ctypes.data_as(ct.c_void_p), ct.c_int(ballradius)) if magnifyBlue > 0: show[:, :, 0] = np.maximum(show[:, :, 0], np.roll(show[:, :, 0], 1, axis=0)) if magnifyBlue >= 2: show[:, :, 0] = np.maximum(show[:, :, 0], np.roll(show[:, :, 0], -1, axis=0)) show[:, :, 0] = np.maximum(show[:, :, 0], np.roll(show[:, :, 0], 1, axis=1)) if magnifyBlue >= 2: show[:, :, 0] = np.maximum(show[:, :, 0], np.roll(show[:, :, 0], -1, axis=1)) if showrot: cv2.putText(show, 'xangle %d' % (int(xangle / np.pi * 180)), (30, showsz - 30), 0, 0.5, cv2.cv.CV_RGB(255, 0, 0)) cv2.putText(show, 'yangle %d' % (int(yangle / np.pi * 180)), (30, showsz - 50), 0, 0.5, cv2.cv.CV_RGB(255, 0, 0)) cv2.putText(show, 'zoom %d%%' % (int(zoom * 100)), (30, showsz - 70), 0, 0.5, cv2.cv.CV_RGB(255, 0, 0)) changed = True while True: if changed: render() changed = False cv2.imshow('show3d', show) if waittime == 0: cmd = cv2.waitKey(10) % 256 else: cmd = cv2.waitKey(waittime) % 256 if cmd == ord('q'): break elif cmd == ord('Q'): sys.exit(0) if cmd == ord('t') or cmd == ord('p'): if cmd == ord('t'): if c_gt is None: c0 = np.zeros((len(xyz), ), dtype='float32') + 255 c1 = np.zeros((len(xyz), ), dtype='float32') + 255 c2 = np.zeros((len(xyz), ), dtype='float32') + 255 else: c0 = c_gt[:, 0] c1 = c_gt[:, 1] c2 = c_gt[:, 2] else: if c_pred is None: c0 = np.zeros((len(xyz), ), dtype='float32') + 255 c1 = np.zeros((len(xyz), ), dtype='float32') + 255 c2 = np.zeros((len(xyz), ), dtype='float32') + 255 else: c0 = c_pred[:, 0] c1 = c_pred[:, 1] c2 = c_pred[:, 2] if normalizecolor: c0 /= (c0.max() + 1e-14) / 255.0 c1 /= (c1.max() + 1e-14) / 255.0 c2 /= (c2.max() + 1e-14) / 255.0 c0 = np.require(c0, 'float32', 'C') c1 = np.require(c1, 'float32', 'C') c2 = np.require(c2, 'float32', 'C') changed = True if cmd == ord('n'): zoom *= 1.1 changed = True elif cmd == ord('m'): zoom /= 1.1 changed = True elif cmd == ord('r'): zoom = 1.0 changed = True elif cmd == ord('s'): cv2.imwrite('show3d.png', show) if waittime != 0: break return cmd
def actionAngleTorus_hessian_c(pot, jr, jphi, jz, tol=0.003, dJ=0.001): """ NAME: actionAngleTorus_hessian_c PURPOSE: compute dO/dJ on a single torus INPUT: pot - Potential object or list thereof jr - radial action (scalar) jphi - azimuthal action (scalar) jz - vertical action (scalar) tol= (0.003) goal for |dJ|/|J| along the torus dJ= (0.001) action difference when computing derivatives (Hessian or Jacobian) OUTPUT: (dO/dJ,Omegar,Omegaphi,Omegaz,Autofit error flag) Note: dO/dJ is *not* symmetrized here HISTORY: 2016-07-15 - Written - Bovy (UofT) """ #Parse the potential from ..orbit.integrateFullOrbit import _parse_pot npot, pot_type, pot_args = _parse_pot(pot, potfortorus=True) #Set up result dOdJT = numpy.empty(9) Omegar = numpy.empty(1) Omegaphi = numpy.empty(1) Omegaz = numpy.empty(1) flag = ctypes.c_int(0) #Set up the C code ndarrayFlags = ('C_CONTIGUOUS', 'WRITEABLE') actionAngleTorus_HessFunc = _lib.actionAngleTorus_hessianFreqs actionAngleTorus_HessFunc.argtypes=\ [ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.c_int, ndpointer(dtype=numpy.int32,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ctypes.c_double, ctypes.c_double, ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ctypes.POINTER(ctypes.c_int)] #Array requirements dOdJT = numpy.require(dOdJT, dtype=numpy.float64, requirements=['C', 'W']) Omegar = numpy.require(Omegar, dtype=numpy.float64, requirements=['C', 'W']) Omegaphi = numpy.require(Omegaphi, dtype=numpy.float64, requirements=['C', 'W']) Omegaz = numpy.require(Omegaz, dtype=numpy.float64, requirements=['C', 'W']) #Run the C code actionAngleTorus_HessFunc(ctypes.c_double(jr), ctypes.c_double(jphi), ctypes.c_double(jz), ctypes.c_int(npot), pot_type, pot_args, ctypes.c_double(tol), ctypes.c_double(dJ), dOdJT, Omegar, Omegaphi, Omegaz, ctypes.byref(flag)) return (dOdJT.reshape( (3, 3)).T, Omegar[0], Omegaphi[0], Omegaz[0], flag.value)
def FORCESNLPsolver_solve(params_arg): ''' a Python wrapper for a fast solver generated by FORCES Pro v1.6.121 OUTPUT = FORCESNLPsolver_py.FORCESNLPsolver_solve(PARAMS) solves a multistage problem subject to the parameters supplied in the following dictionary: PARAMS['x0'] - column vector of length 600 PARAMS['xinit'] - column vector of length 4 PARAMS['xfinal'] - column vector of length 2 OUTPUT returns the values of the last iteration of the solver where OUTPUT['x001'] - column vector of size 6 OUTPUT['x002'] - column vector of size 6 OUTPUT['x003'] - column vector of size 6 OUTPUT['x004'] - column vector of size 6 OUTPUT['x005'] - column vector of size 6 OUTPUT['x006'] - column vector of size 6 OUTPUT['x007'] - column vector of size 6 OUTPUT['x008'] - column vector of size 6 OUTPUT['x009'] - column vector of size 6 OUTPUT['x010'] - column vector of size 6 OUTPUT['x011'] - column vector of size 6 OUTPUT['x012'] - column vector of size 6 OUTPUT['x013'] - column vector of size 6 OUTPUT['x014'] - column vector of size 6 OUTPUT['x015'] - column vector of size 6 OUTPUT['x016'] - column vector of size 6 OUTPUT['x017'] - column vector of size 6 OUTPUT['x018'] - column vector of size 6 OUTPUT['x019'] - column vector of size 6 OUTPUT['x020'] - column vector of size 6 OUTPUT['x021'] - column vector of size 6 OUTPUT['x022'] - column vector of size 6 OUTPUT['x023'] - column vector of size 6 OUTPUT['x024'] - column vector of size 6 OUTPUT['x025'] - column vector of size 6 OUTPUT['x026'] - column vector of size 6 OUTPUT['x027'] - column vector of size 6 OUTPUT['x028'] - column vector of size 6 OUTPUT['x029'] - column vector of size 6 OUTPUT['x030'] - column vector of size 6 OUTPUT['x031'] - column vector of size 6 OUTPUT['x032'] - column vector of size 6 OUTPUT['x033'] - column vector of size 6 OUTPUT['x034'] - column vector of size 6 OUTPUT['x035'] - column vector of size 6 OUTPUT['x036'] - column vector of size 6 OUTPUT['x037'] - column vector of size 6 OUTPUT['x038'] - column vector of size 6 OUTPUT['x039'] - column vector of size 6 OUTPUT['x040'] - column vector of size 6 OUTPUT['x041'] - column vector of size 6 OUTPUT['x042'] - column vector of size 6 OUTPUT['x043'] - column vector of size 6 OUTPUT['x044'] - column vector of size 6 OUTPUT['x045'] - column vector of size 6 OUTPUT['x046'] - column vector of size 6 OUTPUT['x047'] - column vector of size 6 OUTPUT['x048'] - column vector of size 6 OUTPUT['x049'] - column vector of size 6 OUTPUT['x050'] - column vector of size 6 OUTPUT['x051'] - column vector of size 6 OUTPUT['x052'] - column vector of size 6 OUTPUT['x053'] - column vector of size 6 OUTPUT['x054'] - column vector of size 6 OUTPUT['x055'] - column vector of size 6 OUTPUT['x056'] - column vector of size 6 OUTPUT['x057'] - column vector of size 6 OUTPUT['x058'] - column vector of size 6 OUTPUT['x059'] - column vector of size 6 OUTPUT['x060'] - column vector of size 6 OUTPUT['x061'] - column vector of size 6 OUTPUT['x062'] - column vector of size 6 OUTPUT['x063'] - column vector of size 6 OUTPUT['x064'] - column vector of size 6 OUTPUT['x065'] - column vector of size 6 OUTPUT['x066'] - column vector of size 6 OUTPUT['x067'] - column vector of size 6 OUTPUT['x068'] - column vector of size 6 OUTPUT['x069'] - column vector of size 6 OUTPUT['x070'] - column vector of size 6 OUTPUT['x071'] - column vector of size 6 OUTPUT['x072'] - column vector of size 6 OUTPUT['x073'] - column vector of size 6 OUTPUT['x074'] - column vector of size 6 OUTPUT['x075'] - column vector of size 6 OUTPUT['x076'] - column vector of size 6 OUTPUT['x077'] - column vector of size 6 OUTPUT['x078'] - column vector of size 6 OUTPUT['x079'] - column vector of size 6 OUTPUT['x080'] - column vector of size 6 OUTPUT['x081'] - column vector of size 6 OUTPUT['x082'] - column vector of size 6 OUTPUT['x083'] - column vector of size 6 OUTPUT['x084'] - column vector of size 6 OUTPUT['x085'] - column vector of size 6 OUTPUT['x086'] - column vector of size 6 OUTPUT['x087'] - column vector of size 6 OUTPUT['x088'] - column vector of size 6 OUTPUT['x089'] - column vector of size 6 OUTPUT['x090'] - column vector of size 6 OUTPUT['x091'] - column vector of size 6 OUTPUT['x092'] - column vector of size 6 OUTPUT['x093'] - column vector of size 6 OUTPUT['x094'] - column vector of size 6 OUTPUT['x095'] - column vector of size 6 OUTPUT['x096'] - column vector of size 6 OUTPUT['x097'] - column vector of size 6 OUTPUT['x098'] - column vector of size 6 OUTPUT['x099'] - column vector of size 6 OUTPUT['x100'] - column vector of size 6 [OUTPUT, EXITFLAG] = FORCESNLPsolver_py.FORCESNLPsolver_solve(PARAMS) returns additionally the integer EXITFLAG indicating the state of the solution with 1 - Optimal solution has been found (subject to desired accuracy) 2 - (only branch-and-bound) A feasible point has been identified for which the objective value is no more than codeoptions.mip.mipgap*100 per cent worse than the global optimum 0 - Timeout - maximum number of iterations reached -1 - (only branch-and-bound) Infeasible problem (problems solving the root relaxation to the desired accuracy) -2 - (only branch-and-bound) Out of memory - cannot fit branch and bound nodes into pre-allocated memory. -6 - NaN or INF occured during evaluation of functions and derivatives. Please check your initial guess. -7 - Method could not progress. Problem may be infeasible. Run FORCESdiagnostics on your problem to check for most common errors in the formulation. -10 - The convex solver could not proceed due to an internal error -100 - License error [OUTPUT, EXITFLAG, INFO] = FORCESNLPsolver_py.FORCESNLPsolver_solve(PARAMS) returns additional information about the last iterate: INFO.it - number of iterations that lead to this result INFO.it2opt - number of convex solves INFO.res_eq - max. equality constraint residual INFO.res_ineq - max. inequality constraint residual INFO.rsnorm - norm of stationarity condition INFO.rcompnorm - max of all complementarity violations INFO.pobj - primal objective INFO.mu - duality measure INFO.solvetime - Time needed for solve (wall clock time) INFO.fevalstime - Time needed for function evaluations (wall clock time) See also COPYING ''' global _lib # convert parameters params_py = FORCESNLPsolver_params_ctypes() for par in params_arg: try: #setattr(params_py, par, npct.as_ctypes(np.reshape(params_arg[par],np.size(params_arg[par]),order='A'))) params_arg[par] = np.require(params_arg[par], dtype=np.float64, requirements='F') setattr( params_py, par, npct.as_ctypes( np.reshape(params_arg[par], np.size(params_arg[par]), order='F'))) except: raise ValueError( 'Parameter ' + par + ' does not have the appropriate dimensions or data type. Please use numpy arrays for parameters.' ) outputs_py = FORCESNLPsolver_outputs_ctypes() info_py = FORCESNLPsolver_info() if sys.version_info.major == 2: if sys.platform.startswith('win'): fp = None # if set to none, the solver prints to stdout by default - necessary because we have an access violation otherwise under windows else: #fp = open('stdout_temp.txt','w') fp = sys.stdout try: PyFile_AsFile.restype = ctypes.POINTER(FILE) exitflag = _lib.FORCESNLPsolver_solve( params_py, ctypes.byref(outputs_py), ctypes.byref(info_py), PyFile_AsFile(fp), _lib.FORCESNLPsolver_casadi2forces) #fp = open('stdout_temp.txt','r') #print (fp.read()) #fp.close() except: #print 'Problem with solver' raise elif sys.version_info.major == 3: if sys.platform.startswith('win'): libc = ctypes.cdll.msvcrt elif sys.platform.startswith('darwin'): libc = ctypes.CDLL('libc.dylib') else: libc = ctypes.CDLL('libc.so.6') # Open libc cfopen = getattr(libc, 'fopen') # Get its fopen cfopen.restype = ctypes.POINTER( FILE) # Yes, fopen gives a file pointer cfopen.argtypes = [ctypes.c_char_p, ctypes.c_char_p] # Yes, fopen gives a file pointer fp = cfopen('stdout_temp.txt'.encode('utf-8'), 'w'.encode('utf-8')) # Use that fopen try: if sys.platform.startswith('win'): exitflag = _lib.FORCESNLPsolver_solve( params_py, ctypes.byref(outputs_py), ctypes.byref(info_py), None, _lib.FORCESNLPsolver_casadi2forces) else: exitflag = _lib.FORCESNLPsolver_solve( params_py, ctypes.byref(outputs_py), ctypes.byref(info_py), fp, _lib.FORCESNLPsolver_casadi2forces) libc.fclose(fp) fptemp = open('stdout_temp.txt', 'r') print(fptemp.read()) fptemp.close() except: #print 'Problem with solver' raise # convert outputs for out in FORCESNLPsolver_outputs: FORCESNLPsolver_outputs[out] = npct.as_array(getattr(outputs_py, out)) return FORCESNLPsolver_outputs, int(exitflag), info_py
def unwrap_phase(image, wrap_around=False, seed=None): '''Recover the original from a wrapped phase image. From an image wrapped to lie in the interval [-pi, pi), recover the original, unwrapped image. Parameters ---------- image : 1D, 2D or 3D ndarray of floats, optionally a masked array The values should be in the range [-pi, pi). If a masked array is provided, the masked entries will not be changed, and their values will not be used to guide the unwrapping of neighboring, unmasked values. Masked 1D arrays are not allowed, and will raise a `ValueError`. wrap_around : bool or sequence of bool, optional When an element of the sequence is `True`, the unwrapping process will regard the edges along the corresponding axis of the image to be connected and use this connectivity to guide the phase unwrapping process. If only a single boolean is given, it will apply to all axes. Wrap around is not supported for 1D arrays. seed : int, optional Unwrapping 2D or 3D images uses random initialization. This sets the seed of the PRNG to achieve deterministic behavior. Returns ------- image_unwrapped : array_like, double Unwrapped image of the same shape as the input. If the input `image` was a masked array, the mask will be preserved. Raises ------ ValueError If called with a masked 1D array or called with a 1D array and ``wrap_around=True``. Examples -------- >>> c0, c1 = np.ogrid[-1:1:128j, -1:1:128j] >>> image = 12 * np.pi * np.exp(-(c0**2 + c1**2)) >>> image_wrapped = np.angle(np.exp(1j * image)) >>> image_unwrapped = unwrap_phase(image_wrapped) >>> np.std(image_unwrapped - image) < 1e-6 # A constant offset is normal True References ---------- .. [1] Miguel Arevallilo Herraez, David R. Burton, Michael J. Lalor, and Munther A. Gdeisat, "Fast two-dimensional phase-unwrapping algorithm based on sorting by reliability following a noncontinuous path", Journal Applied Optics, Vol. 41, No. 35 (2002) 7437, .. [2] Abdul-Rahman, H., Gdeisat, M., Burton, D., & Lalor, M., "Fast three-dimensional phase-unwrapping algorithm based on sorting by reliability following a non-continuous path. In W. Osten, C. Gorecki, & E. L. Novak (Eds.), Optical Metrology (2005) 32--40, International Society for Optics and Photonics. ''' if image.ndim not in (1, 2, 3): raise ValueError('Image must be 1, 2, or 3 dimensional') if isinstance(wrap_around, bool): wrap_around = [wrap_around] * image.ndim elif (hasattr(wrap_around, '__getitem__') and not isinstance(wrap_around, str)): if len(wrap_around) != image.ndim: raise ValueError('Length of `wrap_around` must equal the ' 'dimensionality of image') wrap_around = [bool(wa) for wa in wrap_around] else: raise ValueError('`wrap_around` must be a bool or a sequence with ' 'length equal to the dimensionality of image') if image.ndim == 1: if np.ma.isMaskedArray(image): raise ValueError('1D masked images cannot be unwrapped') if wrap_around[0]: raise ValueError('`wrap_around` is not supported for 1D images') if image.ndim in (2, 3) and 1 in image.shape: warn('Image has a length 1 dimension. Consider using an ' 'array of lower dimensionality to use a more efficient ' 'algorithm') if np.ma.isMaskedArray(image): mask = np.require(np.ma.getmaskarray(image), np.uint8, ['C']) else: mask = np.zeros_like(image, dtype=np.uint8, order='C') image_not_masked = np.asarray(np.ma.getdata(image), dtype=np.double, order='C') image_unwrapped = np.empty_like(image, dtype=np.double, order='C', subok=False) if image.ndim == 1: unwrap_1d(image_not_masked, image_unwrapped) elif image.ndim == 2: unwrap_2d(image_not_masked, mask, image_unwrapped, wrap_around, seed) elif image.ndim == 3: unwrap_3d(image_not_masked, mask, image_unwrapped, wrap_around, seed) if np.ma.isMaskedArray(image): return np.ma.array(image_unwrapped, mask=mask, fill_value=image.fill_value) else: return image_unwrapped
def actionAngleTorus_jacobian_c(pot, jr, jphi, jz, angler, anglephi, anglez, tol=0.003, dJ=0.001): """ NAME: actionAngleTorus_jacobian_c PURPOSE: compute d(x,v)/d(J,theta) on a single torus, also compute dO/dJ and the frequencies INPUT: pot - Potential object or list thereof jr - radial action (scalar) jphi - azimuthal action (scalar) jz - vertical action (scalar) angler - radial angle (array [N]) anglephi - azimuthal angle (array [N]) anglez - vertical angle (array [N]) tol= (0.003) goal for |dJ|/|J| along the torus dJ= (0.001) action difference when computing derivatives (Hessian or Jacobian) OUTPUT: (d[R,vR,vT,z,vz,phi]/d[J,theta], Omegar,Omegaphi,Omegaz, Autofit error message) Note: dO/dJ is *not* symmetrized here HISTORY: 2016-07-19 - Written - Bovy (UofT) """ #Parse the potential from ..orbit.integrateFullOrbit import _parse_pot npot, pot_type, pot_args = _parse_pot(pot, potfortorus=True) #Set up result R = numpy.empty(len(angler)) vR = numpy.empty(len(angler)) vT = numpy.empty(len(angler)) z = numpy.empty(len(angler)) vz = numpy.empty(len(angler)) phi = numpy.empty(len(angler)) dxvOdJaT = numpy.empty(36 * len(angler)) dOdJT = numpy.empty(9) Omegar = numpy.empty(1) Omegaphi = numpy.empty(1) Omegaz = numpy.empty(1) flag = ctypes.c_int(0) #Set up the C code ndarrayFlags = ('C_CONTIGUOUS', 'WRITEABLE') actionAngleTorus_JacFunc = _lib.actionAngleTorus_jacobianFreqs actionAngleTorus_JacFunc.argtypes=\ [ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.c_int, ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ctypes.c_int, ndpointer(dtype=numpy.int32,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ctypes.c_double, ctypes.c_double, ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ctypes.POINTER(ctypes.c_int)] #Array requirements, first store old order f_cont = [ angler.flags['F_CONTIGUOUS'], anglephi.flags['F_CONTIGUOUS'], anglez.flags['F_CONTIGUOUS'] ] angler = numpy.require(angler, dtype=numpy.float64, requirements=['C', 'W']) anglephi = numpy.require(anglephi, dtype=numpy.float64, requirements=['C', 'W']) anglez = numpy.require(anglez, dtype=numpy.float64, requirements=['C', 'W']) R = numpy.require(R, dtype=numpy.float64, requirements=['C', 'W']) vR = numpy.require(vR, dtype=numpy.float64, requirements=['C', 'W']) vT = numpy.require(vT, dtype=numpy.float64, requirements=['C', 'W']) z = numpy.require(z, dtype=numpy.float64, requirements=['C', 'W']) vz = numpy.require(vz, dtype=numpy.float64, requirements=['C', 'W']) phi = numpy.require(phi, dtype=numpy.float64, requirements=['C', 'W']) dxvOdJaT = numpy.require(dxvOdJaT, dtype=numpy.float64, requirements=['C', 'W']) dOdJT = numpy.require(dOdJT, dtype=numpy.float64, requirements=['C', 'W']) Omegar = numpy.require(Omegar, dtype=numpy.float64, requirements=['C', 'W']) Omegaphi = numpy.require(Omegaphi, dtype=numpy.float64, requirements=['C', 'W']) Omegaz = numpy.require(Omegaz, dtype=numpy.float64, requirements=['C', 'W']) #Run the C code actionAngleTorus_JacFunc(ctypes.c_double(jr), ctypes.c_double(jphi), ctypes.c_double(jz), ctypes.c_int(len(angler)), angler, anglephi, anglez, ctypes.c_int(npot), pot_type, pot_args, ctypes.c_double(tol), ctypes.c_double(dJ), R, vR, vT, z, vz, phi, dxvOdJaT, dOdJT, Omegar, Omegaphi, Omegaz, ctypes.byref(flag)) #Reset input arrays if f_cont[0]: angler = numpy.asfortranarray(angler) if f_cont[1]: anglephi = numpy.asfortranarray(anglephi) if f_cont[2]: anglez = numpy.asfortranarray(anglez) dxvOdJaT = numpy.reshape(dxvOdJaT, (len(angler), 6, 6), order='C') dxvOdJa = numpy.swapaxes(dxvOdJaT, 1, 2) return (R, vR, vT, z, vz, phi, dxvOdJa, dOdJT.reshape( (3, 3)).T, Omegar[0], Omegaphi[0], Omegaz[0], flag.value)
with tf.Session(config=config) as session: saver = tf.train.import_meta_graph('./' + name + '.meta') tf.train.update_checkpoint_state('./', name) saver.restore(session, tf.train.latest_checkpoint('./')) x = tf.get_collection('x')[0] y = tf.get_collection('y')[0] pred = tf.get_collection('p')[0] # Run trained network on the training sample train_data = pandas.read_pickle('inference_training_sample.pickle') x_train = train_data[variables].values y_train = train_data['is_quark'].values x_train = np.require(x_train, dtype=np.float32, requirements=['A', 'W', 'C', 'O']) p = np.zeros(len(y_train)) for i in range(0, len(y_train), 100000): e = i + 100000 e = min(len(y_train), e) p[i:e] = apply(x_train[i:e], session, x, pred) # Save results and print out ROC value df_result_train = pandas.DataFrame({'y': y_train, 'p': p}) df_result_train.to_pickle('result_train_with_boost.pickle') print("train", sklearn.metrics.roc_auc_score(y_train, p)) del train_data # Run trained network on the test sample
def actionAngleTorus_Freqs_c(pot, jr, jphi, jz, tol=0.003): """ NAME: actionAngleTorus_Freqs_c PURPOSE: compute frequencies on a single torus INPUT: pot - Potential object or list thereof jr - radial action (scalar) jphi - azimuthal action (scalar) jz - vertical action (scalar) tol= (0.003) goal for |dJ|/|J| along the torus OUTPUT: (Omegar,Omegaphi,Omegaz,flag) HISTORY: 2015-08-05/07 - Written - Bovy (UofT) """ #Parse the potential from ..orbit.integrateFullOrbit import _parse_pot npot, pot_type, pot_args = _parse_pot(pot, potfortorus=True) #Set up result Omegar = numpy.empty(1) Omegaphi = numpy.empty(1) Omegaz = numpy.empty(1) flag = ctypes.c_int(0) #Set up the C code ndarrayFlags = ('C_CONTIGUOUS', 'WRITEABLE') actionAngleTorus_FreqsFunc = _lib.actionAngleTorus_Freqs actionAngleTorus_FreqsFunc.argtypes=\ [ctypes.c_double, ctypes.c_double, ctypes.c_double, ctypes.c_int, ndpointer(dtype=numpy.int32,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ctypes.c_double, ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ndpointer(dtype=numpy.float64,flags=ndarrayFlags), ctypes.POINTER(ctypes.c_int)] #Array requirements Omegar = numpy.require(Omegar, dtype=numpy.float64, requirements=['C', 'W']) Omegaphi = numpy.require(Omegaphi, dtype=numpy.float64, requirements=['C', 'W']) Omegaz = numpy.require(Omegaz, dtype=numpy.float64, requirements=['C', 'W']) #Run the C code actionAngleTorus_FreqsFunc(ctypes.c_double(jr), ctypes.c_double(jphi), ctypes.c_double(jz), ctypes.c_int(npot), pot_type, pot_args, ctypes.c_double(tol), Omegar, Omegaphi, Omegaz, ctypes.byref(flag)) return (Omegar[0], Omegaphi[0], Omegaz[0], flag.value)
def is_integer(x): return np.array_equal(x, np.require(x, dtype=np.int_))
def require_writeable_array(arr): # This should be fixed in numba (numba issue #2521) return np.require(arr, requirements='W')
def require(data, dtype='f', requirements='CA'): if dtype == 'f': dtype = numpy.float64 elif dtype == 'i': dtype = numpy.intc return numpy.require(data, dtype=dtype, requirements='CA')
def is_binary(x): return np.array_equal(x, np.require(x, dtype=np.bool_))
def reorder(self, a): return np.require(np.transpose(a, axes=self.axes), requirements='C')
def ar_pick(a, b, c, samp_rate, f1, f2, lta_p, sta_p, lta_s, sta_s, m_p, m_s, l_p, l_s, s_pick=True): """ Pick P and S arrivals with an AR-AIC + STA/LTA algorithm. The algorithm picks onset times using an Auto Regression - Akaike Information Criterion (AR-AIC) method. The detection intervals are successively narrowed down with the help of STA/LTA ratios as well as STA-LTA difference calculations. For details, please see [Akazawa2004]_. An important feature of this algorithm is that it requires comparatively little tweaking and site-specific settings and is thus applicable to large, diverse data sets. :type a: :class:`numpy.ndarray` :param a: Z signal the data. :type b: :class:`numpy.ndarray` :param b: N signal of the data. :type c: :class:`numpy.ndarray` :param c: E signal of the data. :type samp_rate: float :param samp_rate: Number of samples per second. :type f1: float :param f1: Frequency of the lower bandpass window. :type f2: float :param f2: Frequency of the upper .andpass window. :type lta_p: float :param lta_p: Length of LTA for the P arrival in seconds. :type sta_p: float :param sta_p: Length of STA for the P arrival in seconds. :type lta_s: float :param lta_s: Length of LTA for the S arrival in seconds. :type sta_s: float :param sta_s: Length of STA for the S arrival in seconds. :type m_p: int :param m_p: Number of AR coefficients for the P arrival. :type m_s: int :param m_s: Number of AR coefficients for the S arrival. :type l_p: float :param l_p: Length of variance window for the P arrival in seconds. :type l_s: float :param l_s: Length of variance window for the S arrival in seconds. :type s_pick: bool :param s_pick: If ``True``, also pick the S phase, otherwise only the P phase. :rtype: tuple :returns: A tuple with the P and the S arrival. """ if not (len(a) == len(b) == len(c)): raise ValueError("All three data arrays must have the same length.") a = scipy.signal.detrend(a, type='linear') b = scipy.signal.detrend(b, type='linear') c = scipy.signal.detrend(c, type='linear') # be nice and adapt type if necessary a = np.require(a, dtype=np.float32, requirements=['C_CONTIGUOUS']) b = np.require(b, dtype=np.float32, requirements=['C_CONTIGUOUS']) c = np.require(c, dtype=np.float32, requirements=['C_CONTIGUOUS']) # scale amplitudes to avoid precision issues in case of low amplitudes # C code picks the horizontal component with larger amplitudes, so scale # horizontal components with a common scaling factor data_max = np.abs(a).max() if data_max < 100: a *= 1e6 a /= data_max data_max = max(np.abs(b).max(), np.abs(c).max()) if data_max < 100: for data in (b, c): data *= 1e6 data /= data_max s_pick = C.c_int(s_pick) # pick S phase also ptime = C.c_float() stime = C.c_float() args = (len(a), samp_rate, f1, f2, lta_p, sta_p, lta_s, sta_s, m_p, m_s, C.byref(ptime), C.byref(stime), l_p, l_s, s_pick) errcode = clibsignal.ar_picker(a, b, c, *args) if errcode != 0: bufs = [ 'buff1', 'buff1_s', 'buff2', 'buff3', 'buff4', 'buff4_s', 'f_error', 'b_error', 'ar_f', 'ar_b', 'buf_sta', 'buf_lta', 'extra_tr1', 'extra_tr2', 'extra_tr3' ] if errcode <= len(bufs): raise MemoryError('Unable to allocate %s!' % (bufs[errcode - 1])) raise Exception('Error during PAZ calculation!') return ptime.value, stime.value
def konno_ohmachi_smoothing(spectra, frequencies, bandwidth=40, count=1, enforce_no_matrix=False, max_memory_usage=512, normalize=False): """ Smooths a matrix containing one spectra per row with the Konno-Ohmachi smoothing window. All spectra need to have frequency bins corresponding to the same frequencies. This method first will estimate the memory usage and then either use a fast and memory intensive method or a slow one with a better memory usage. :type spectra: :class:`numpy.ndarray` (float32 or float64) :param spectra: One or more spectra per row. If more than one the first spectrum has to be accessible via spectra[0], the next via spectra[1], ... :type frequencies: :class:`numpy.ndarray` (float32 or float64) :param frequencies: Contains the frequencies for the spectra. :type bandwidth: float :param bandwidth: Determines the width of the smoothing peak. Lower values result in a broader peak. Must be greater than 0. Defaults to 40. :type count: int, optional :param count: How often the apply the filter. For very noisy spectra it is useful to apply is more than once. Defaults to 1. :type enforce_no_matrix: bool, optional :param enforce_no_matrix: An efficient but memory intensive matrix-multiplication algorithm is used in case more than one spectra is to be smoothed or one spectrum is to be smoothed more than once if enough memory is available. This flag disables the matrix algorithm altogether. Defaults to False :type max_memory_usage: int, optional :param max_memory_usage: Set the maximum amount of extra memory in MB for this method. Decides whether or not the matrix multiplication method is used. Defaults to 512 MB. :type normalize: bool, optional :param normalize: The Konno-Ohmachi smoothing window is normalized on a logarithmic scale. Set this parameter to True to normalize it on a normal scale. Default to False. """ if (frequencies.dtype != np.float32 and frequencies.dtype != np.float64) \ or (spectra.dtype != np.float32 and spectra.dtype != np.float64): msg = 'frequencies and spectra need to have a dtype of float32/64.' raise ValueError(msg) # Spectra and frequencies should have the same dtype. if frequencies.dtype != spectra.dtype: frequencies = np.require(frequencies, np.float64) spectra = np.require(spectra, np.float64) msg = 'frequencies and spectra should have the same dtype. It ' + \ 'will be changed to np.float64 for both.' warnings.warn(msg) # Check the dtype to get the correct size. if frequencies.dtype == np.float32: size = 4.0 elif frequencies.dtype == np.float64: size = 8.0 # Calculate the approximate usage needs for the smoothing matrix algorithm. length = len(frequencies) approx_mem_usage = (length * length + 2 * len(spectra) + length) * \ size / 1048576.0 # If smaller than the allowed maximum memory consumption build a smoothing # matrix and apply to each spectrum. Also only use when more then one # spectrum is to be smoothed. if enforce_no_matrix is False and (len(spectra.shape) > 1 or count > 1) \ and approx_mem_usage < max_memory_usage: # Disable NumPy warnings due to possible divisions by zero/logarithms # of zero. temp = np.geterr() np.seterr(all='ignore') smoothing_matrix = calculate_smoothing_matrix(frequencies, bandwidth, normalize=normalize) np.seterr(**temp) new_spec = np.dot(spectra, smoothing_matrix) # Eventually apply more than once. for _i in range(count - 1): new_spec = np.dot(new_spec, smoothing_matrix) return new_spec # Otherwise just calculate the smoothing window every time and apply it. else: new_spec = np.empty(spectra.shape, spectra.dtype) # Separate case for just one spectrum. if len(new_spec.shape) == 1: # Disable NumPy warnings due to possible divisions by # zero/logarithms of zero. temp = np.geterr() np.seterr(all='ignore') for _i in range(len(frequencies)): window = konno_ohmachi_smoothing_window(frequencies, frequencies[_i], bandwidth, normalize=normalize) new_spec[_i] = (window * spectra).sum() np.seterr(**temp) # Reuse smoothing window if more than one spectrum. else: # Disable NumPy warnings due to possible divisions by # zero/logarithms of zero. temp = np.geterr() np.seterr(all='ignore') for _i in range(len(frequencies)): window = konno_ohmachi_smoothing_window(frequencies, frequencies[_i], bandwidth, normalize=normalize) for _j, spec in enumerate(spectra): new_spec[_j, _i] = (window * spec).sum() np.seterr(**temp) # Eventually apply more than once. while count > 1: new_spec = konno_ohmachi_smoothing(new_spec, frequencies, bandwidth, enforce_no_matrix=True, normalize=normalize) count -= 1 return new_spec
def _estimate(self, trajs): """ Parameters ---------- X : tuple of (ttrajs, dtrajs) Simulation trajectories. ttrajs contain the indices of the thermodynamic state and dtrajs contains the indices of the configurational states. ttrajs : list of numpy.ndarray(X_i, dtype=int) Every elements is a trajectory (time series). ttrajs[i][t] is the index of the thermodynamic state visited in trajectory i at time step t. dtrajs : list of numpy.ndarray(X_i, dtype=int) dtrajs[i][t] is the index of the configurational state (Markov state) visited in trajectory i at time step t. """ # check input assert isinstance(trajs, (tuple, list)) assert len(trajs) == 2 ttrajs = trajs[0] dtrajs = trajs[1] # validate input for ttraj, dtraj in zip(ttrajs, dtrajs): _types.assert_array(ttraj, ndim=1, kind='numeric') _types.assert_array(dtraj, ndim=1, kind='numeric') assert _np.shape(ttraj)[0] == _np.shape(dtraj)[0] # harvest transition counts self.count_matrices_full = _util.count_matrices( ttrajs, dtrajs, self.lag, sliding=self.count_mode, sparse_return=False, nstates=self.nstates_full) # harvest state counts (for WHAM) self.state_counts_full = _util.state_counts(ttrajs, dtrajs, nthermo=self.nthermo, nstates=self.nstates_full) # restrict to connected set C_sum = self.count_matrices_full.sum(axis=0) # TODO: use improved cset cset = _largest_connected_set(C_sum, directed=True) self.active_set = cset # correct counts self.count_matrices = self.count_matrices_full[:, cset[:, _np.newaxis], cset] self.count_matrices = _np.require(self.count_matrices, dtype=_np.intc, requirements=['C', 'A']) # correct bias matrix self.bias_energies = self.bias_energies_full[:, cset] self.bias_energies = _np.require(self.bias_energies, dtype=_np.float64, requirements=['C', 'A']) # correct state counts self.state_counts = self.state_counts_full[:, cset] self.state_counts = _np.require(self.state_counts, dtype=_np.intc, requirements=['C', 'A']) # run initialisation if self.init is not None: if self.init == 'wham': self.therm_energies, self.conf_energies, _increments, _loglikelihoods = \ _wham.estimate( self.state_counts, self.bias_energies, maxiter=self.init_maxiter, maxerr=self.init_maxerr, save_convergence_info=0, therm_energies=self.therm_energies, conf_energies=self.conf_energies, callback=_ConvergenceProgressIndicatorCallBack( self, 'WHAM init.', self.init_maxiter, self.init_maxerr)) self._progress_force_finish(stage='WHAM init.') # run estimator self.therm_energies, self.conf_energies, self.log_lagrangian_mult, \ self.increments, self.loglikelihoods = _dtram.estimate( self.count_matrices, self.bias_energies, maxiter=self.maxiter, maxerr=self.maxerr, log_lagrangian_mult=self.log_lagrangian_mult, conf_energies=self.conf_energies, save_convergence_info=self.save_convergence_info, callback=_ConvergenceProgressIndicatorCallBack( self, 'DTRAM', self.maxiter, self.maxerr)) self._progress_force_finish(stage='DTRAM') # compute models models = [ _dtram.estimate_transition_matrix( self.log_lagrangian_mult, self.bias_energies, self.conf_energies, self.count_matrices, _np.zeros(shape=self.conf_energies.shape, dtype=_np.float64), K) for K in range(self.nthermo) ] self.model_active_set = [ _largest_connected_set(msm, directed=False) for msm in models ] models = [ _np.ascontiguousarray((msm[lcc, :])[:, lcc]) for msm, lcc in zip(models, self.model_active_set) ] # set model parameters to self self.set_model_params(models=[ _MSM(msm, dt_model=self.timestep_traj.get_scaled(self.lag)) for msm in models ], f_therm=self.therm_energies, f=self.conf_energies) # done return self
def read(source, channels, start=None, end=None, scaled=None, type=None, series_class=TimeSeries): # pylint: disable=redefined-builtin """Read a dict of series from one or more GWF files Parameters ---------- source : `str`, `list` Source of data, any of the following: - `str` path of single data file, - `str` path of cache file, - `list` of paths. channels : `~gwpy.detector.ChannelList`, `list` a list of channels to read from the source. start : `~gwpy.time.LIGOTimeGPS`, `float`, `str` optional GPS start time of required data, anything parseable by :func:`~gwpy.time.to_gps` is fine. end : `~gwpy.time.LIGOTimeGPS`, `float`, `str`, optional GPS end time of required data, anything parseable by :func:`~gwpy.time.to_gps` is fine. scaled : `bool`, optional apply slope and bias calibration to ADC data. type : `dict`, optional a `dict` of ``(name, channel-type)`` pairs, where ``channel-type`` can be one of ``'adc'``, ``'proc'``, or ``'sim'``. series_class : `type`, optional the `Series` sub-type to return. Returns ------- data : `~gwpy.timeseries.TimeSeriesDict` or similar a dict of ``(channel, series)`` pairs read from the GWF source(s). """ # parse input source source = file_list(source) # parse type ctype = channel_dict_kwarg(type, channels, (str, )) # read each individually and append out = series_class.DictClass() for i, file_ in enumerate(source): if i == 1: # force data into fresh memory so that append works for name in out: out[name] = numpy.require(out[name], requirements=['O']) # read frame out.append(read_gwf(file_, channels, start=start, end=end, ctype=ctype, scaled=scaled, series_class=series_class), copy=False) return out
def conv(buff, *args, **kwargs): # pylint: disable=unused-argument n = args[size_arg_pos] data = ctypes.string_at(buff, n * dformat.size) return np.require(np.frombuffer(data, dtype=dformat.to_desc("numpy")), requirements="W")
def append(self, trace, gap_overlap_check=False, verbose=False): """ Appends a Trace object to this RtTrace. Registered real-time processing will be applied to copy of appended Trace object before it is appended. This RtTrace will be truncated from the beginning to RtTrace.max_length, if specified. Sampling rate, data type and trace.id of both traces must match. :type trace: :class:`~obspy.core.trace.Trace` :param trace: :class:`~obspy.core.trace.Trace` object to append to this RtTrace :type gap_overlap_check: bool, optional :param gap_overlap_check: Action to take when there is a gap or overlap between the end of this RtTrace and start of appended Trace: * If True, raise TypeError. * If False, all trace processing memory will be re-initialized to prevent false signal in processed trace. (default is ``True``). :type verbose: bool, optional :param verbose: Print additional information to stdout :return: NumPy :class:`~numpy.ndarray` object containing processed trace data from appended Trace object. """ if not isinstance(trace, Trace): # only add Trace objects raise TypeError("Only obspy.core.trace.Trace objects are allowed") # sanity checks if self.have_appended_data: # check id if self.getId() != trace.getId(): raise TypeError("Trace ID differs:", self.getId(), trace.getId()) # check sample rate if self.stats.sampling_rate != trace.stats.sampling_rate: raise TypeError("Sampling rate differs:", self.stats.sampling_rate, trace.stats.sampling_rate) # check calibration factor if self.stats.calib != trace.stats.calib: raise TypeError("Calibration factor differs:", self.stats.calib, trace.stats.calib) # check data type if self.data.dtype != trace.data.dtype: raise TypeError("Data type differs:", self.data.dtype, trace.data.dtype) # TODO: IMPORTANT? Should improve check for gaps and overlaps # and handle more elegantly # check times gap_or_overlap = False if self.have_appended_data: # delta = int(math.floor(\ # round((rt.stats.starttime - lt.stats.endtime) * sr, 5) )) - 1 diff = trace.stats.starttime - self.stats.endtime delta = diff * self.stats.sampling_rate - 1.0 if verbose: msg = "%s: Overlap/gap of (%g) samples in data: (%s) (%s) " + \ "diff=%gs dt=%gs" print(msg % (self.__class__.__name__, delta, self.stats.endtime, trace.stats.starttime, diff, self.stats.delta)) if delta < -0.1: msg = "Overlap of (%g) samples in data: (%s) (%s) diff=%gs" + \ " dt=%gs" msg = msg % (-delta, self.stats.endtime, trace.stats.starttime, diff, self.stats.delta) if gap_overlap_check: raise TypeError(msg) gap_or_overlap = True if delta > 0.1: msg = "Gap of (%g) samples in data: (%s) (%s) diff=%gs" + \ " dt=%gs" msg = msg % (delta, self.stats.endtime, trace.stats.starttime, diff, self.stats.delta) if gap_overlap_check: raise TypeError(msg) gap_or_overlap = True if gap_or_overlap: msg += " - Trace processing memory will be re-initialized." warnings.warn(msg, UserWarning) else: # correct start time to pin absolute trace timing to start of # appended trace, this prevents slow drift of nominal trace # timing from absolute time when nominal sample rate differs # from true sample rate self.stats.starttime = \ self.stats.starttime + diff - self.stats.delta if verbose: print("%s: self.stats.starttime adjusted by: %gs" % (self.__class__.__name__, diff - self.stats.delta)) # first apply all registered processing to Trace for proc in self.processing: process_name, options, rtmemory_list = proc # if gap or overlap, clear memory if gap_or_overlap and rtmemory_list is not None: for n in range(len(rtmemory_list)): rtmemory_list[n] = RtMemory() # apply processing trace = trace.copy() dtype = trace.data.dtype if hasattr(process_name, '__call__'): # check if direct function call trace.data = process_name(trace.data, **options) else: # got predefined function func = REALTIME_PROCESS_FUNCTIONS[process_name.lower()][0] options['rtmemory_list'] = rtmemory_list trace.data = func(trace, **options) # assure dtype is not changed trace.data = np.require(trace.data, dtype=dtype) # if first data, set stats if not self.have_appended_data: self.data = np.array(trace.data) self.stats = Stats(header=trace.stats) self.have_appended_data = True return trace # handle all following data sets # fix Trace.__add__ parameters # TODO: IMPORTANT? Should check for gaps and overlaps and handle # more elegantly sum_trace = Trace.__add__(self, trace, method=0, interpolation_samples=0, fill_value='latest', sanity_checks=True) # Trace.__add__ returns new Trace, so update to this RtTrace self.data = sum_trace.data # left trim if data length exceeds max_length if self.max_length is not None: max_samples = int(self.max_length * self.stats.sampling_rate + 0.5) if np.size(self.data) > max_samples: starttime = self.stats.starttime + \ (np.size(self.data) - max_samples) / \ self.stats.sampling_rate self._ltrim(starttime, pad=False, nearest_sample=True, fill_value=None) return trace
squeeze_me=True) # specify filename to load os.chdir(owd) X = mat['X'] # output data, structured lengthscale = mat['lengthscale'] # lengthscales l lengthscale_p = mat['lengthscale_p'] # lengthscales p sn = mat['sn'] # noise parameter sf = mat['sf'] # power parameter S = mat['S'] # spectral points MU = mat['MU'] # variational latent state SIGMA = mat['SIGMA'] # variational latent state variance U = np.array(mat['U'], dtype=np.float64) # pseudo input points b = mat['b'] # phases # eliminate bad matlab to python coversion X = np.require(X, dtype=None, requirements='A') lengthscale = np.require(lengthscale, dtype=None, requirements='A') lengthscale_p = np.require(lengthscale_p, dtype=None, requirements='A') sn = np.require(sn, dtype=None, requirements='A') sf = np.require(sf, dtype=None, requirements='A') S = np.require(S, dtype=None, requirements='A') MU = np.require(MU, dtype=None, requirements='A') SIGMA = np.require(SIGMA, dtype=None, requirements='A') U = np.require(U, dtype=None, requirements='A') b = np.require(b, dtype=None, requirements='A') Q = MU.shape[1] # input data dimension (N, D) = X.shape # output data dimension M = U.shape[0] # S = np.random.normal(0, 1,(M,Q))
def _run_reco(args): np.seterr(divide='ignore', invalid='ignore') # Create par struct to store parameters par = {} ############################################################################### # Read Input data ########################################################### ############################################################################### if args.data == '': raise ValueError("No data file specified") name = os.path.normpath(args.data) fname = name.split(os.sep)[-1] h5_dataset = h5py.File(name, 'r') par["file"] = h5_dataset h5_dataset_rawdata_name = 'rawdata' h5_dataset_trajectory_name = 'trajectory' if "heart" in args.data: if args.acc == 2: R = 33 trajectory = h5_dataset.get(h5_dataset_trajectory_name)[:, :, :33] rawdata = h5_dataset.get(h5_dataset_rawdata_name)[:, :, :33, :] elif args.acc == 3: R = 22 trajectory = h5_dataset.get(h5_dataset_trajectory_name)[:, :, :22] rawdata = h5_dataset.get(h5_dataset_rawdata_name)[:, :, :22, :] elif args.acc == 4: R = 11 trajectory = h5_dataset.get(h5_dataset_trajectory_name)[:, :, :11] rawdata = h5_dataset.get(h5_dataset_rawdata_name)[:, :, :11, :] else: R = 55 trajectory = h5_dataset.get(h5_dataset_trajectory_name)[...] rawdata = h5_dataset.get(h5_dataset_rawdata_name)[...] else: R = args.acc trajectory = h5_dataset.get(h5_dataset_trajectory_name)[:, :, ::R] rawdata = h5_dataset.get(h5_dataset_rawdata_name)[:, :, ::R, :] [dummy, nFE, nSpokes, nCh] = rawdata.shape ############################################################################### # Read Data ################################################################### ############################################################################### par["ogf"] = float(eval(args.ogf)) dimX, dimY, NSlice = [int(nFE / par["ogf"]), int(nFE / par["ogf"]), 1] data = np.require(np.squeeze(rawdata.T)[None, :, None, ...], requirements='C') par["traj"] = np.require( (trajectory[0] / (2 * np.max(trajectory[0])) + 1j * trajectory[1] / (2 * np.max(trajectory[0]))).T[None, ...], requirements='C') par["dcf"] = np.sqrt(np.array(goldcomp.cmp(par["traj"]), dtype=DTYPE_real)).astype(DTYPE_real) par["dcf"] = np.require(np.abs(par["dcf"]), DTYPE_real, requirements='C') [NScan, NC, reco_Slices, Nproj, N] = data.shape ############################################################################### # Set sequence related parameters ############################################# ############################################################################### par["NC"] = NC par["dimY"] = dimY par["dimX"] = dimX par["NSlice"] = NSlice par["NScan"] = NScan par["N"] = N par["Nproj"] = Nproj ############################################################################### # Create OpenCL Context and Queues ############################################ ############################################################################### platforms = cl.get_platforms() par["GPU"] = False par["Platform_Indx"] = 0 for j in range(len(platforms)): if platforms[j].get_devices(device_type=cl.device_type.GPU): print( "GPU OpenCL platform <%s> found\ with %i device(s) and OpenCL-version <%s>" % (str(platforms[j].get_info(cl.platform_info.NAME)), len(platforms[j].get_devices(device_type=cl.device_type.GPU)), str(platforms[j].get_info(cl.platform_info.VERSION)))) par["GPU"] = True par["Platform_Indx"] = j if not par["GPU"]: print("No GPU OpenCL platform found. Returning.") par["ctx"] = [] par["queue"] = [] num_dev = len(platforms[par["Platform_Indx"]].get_devices()) par["num_dev"] = num_dev for device in range(num_dev): dev = [] dev.append(platforms[par["Platform_Indx"]].get_devices()[device]) tmp = cl.Context(dev) par["ctx"].append(tmp) par["queue"].append( cl.CommandQueue( tmp, platforms[par["Platform_Indx"]].get_devices()[device], properties=cl.command_queue_properties. OUT_OF_ORDER_EXEC_MODE_ENABLE | cl.command_queue_properties.PROFILING_ENABLE)) ############################################################################### # Coil Sensitivity Estimation ################################################# ############################################################################### img_igrid = bart(1, 'nufft -i -t', trajectory, rawdata) img_igrid_sos = bart(1, 'rss 8', img_igrid) img_igrid_sos = np.abs(img_igrid_sos).astype(DTYPE) try: slices_coils = par["file"]['Coils'][()].shape[1] print("Using precomputed coil sensitivities") par["C"] = par["file"]['Coils'][ :, int(slices_coils/2) - int(np.floor((par["NSlice"])/2)): int(slices_coils/2) + int(np.ceil(par["NSlice"]/2)), ...]\ .astype(DTYPE) par["InScale"] = par["file"]["InScale"][ int(slices_coils/2)-int(np.floor((par["NSlice"])/2)): int(slices_coils/2)+int(np.ceil(par["NSlice"]/2)), ...]\ .astype(DTYPE_real) except KeyError: img_igrid = bart(1, 'nufft -i -t', trajectory, rawdata) data_bart = np.fft.fftshift( np.fft.fft2(np.fft.ifftshift(img_igrid.T, (-2, -1)), norm='ortho'), (-2, -1)) data_bart = np.require(np.squeeze(data_bart.T).astype(DTYPE), requirements='C')[None, ...] sens_maps = bart(1, 'ecalib -m1 -I', data_bart) sens_maps = np.require(np.squeeze(sens_maps).T, requirements='C') par["C"] = sens_maps[:, None, ...] par["C"] = np.require(np.transpose(par["C"], (0, 1, 3, 2)), requirements='C') sumSqrC = np.sqrt(np.sum(np.abs(par["C"] * np.conj(par["C"])), 0)) par["C"] = par["C"] / np.tile(sumSqrC, (par["NC"], 1, 1, 1)) par["C"][~np.isfinite(par["C"])] = 0 # #### Remove backfoled part at the top # par["C"][:, :, :20, :] = 0 par["InScale"] = sumSqrC par["file"].create_dataset('Coils', shape=par["C"].shape, dtype=DTYPE, data=par["C"]) par["file"].create_dataset('InScale', shape=sumSqrC.shape, dtype=DTYPE_real, data=sumSqrC) del sumSqrC par["file"].close() ############################################################################### # Set Intensity and Density Scaling ########################################### ############################################################################### if args.inscale: pass else: par["C"] *= par["InScale"] par["InScale"] = np.ones_like(par["InScale"]) if args.denscor: data = data * (par["dcf"]) else: par["dcf"] = np.ones_like(par["dcf"]) ############################################################################### # generate nFFT ############################################################## ############################################################################### FFT = utils.NUFFT(par) def nFTH(x, fft, par): siz = np.shape(x) result = np.require(np.zeros( (par["NC"], par["NSlice"], par["NScan"], par["dimY"], par["dimX"]), dtype=DTYPE), requirements='C') tmp_result = clarray.empty( fft.queue, (par["NScan"], 1, 1, par["dimY"], par["dimX"]), dtype=DTYPE) for j in range(siz[1]): for k in range(siz[2]): inp = clarray.to_device( fft.queue, np.require(x[:, j, k, ...][:, None, None, ...], requirements='C')) fft.adj_NUFFT(tmp_result, inp) result[j, k, ...] = np.squeeze(tmp_result.get()) return np.transpose(result, (2, 0, 1, 3, 4)) images_coils = nFTH(data, FFT, par) images = np.require(np.sum(images_coils * (np.conj(par["C"])), axis=1), requirements='C') del FFT, nFTH opt = CGReco(par) opt.data = data ############################################################################### # Start Reco ################################################################## ############################################################################### opt.reco_par = utils.read_config(args.config, "DEFAULT") opt.execute() result = (opt.result) res = opt.res del opt ############################################################################### # New .hdf5 save files ######################################################## ############################################################################### outdir = "" if "heart" in args.data: outdir += "/heart" elif "brain" in args.data: outdir += "/brain" if not os.path.exists('./output'): os.makedirs('output') if not os.path.exists('./output' + outdir): os.makedirs("./output" + outdir) cwd = os.getcwd() os.chdir("./output" + outdir) f = h5py.File( "CG_reco_InScale_" + str(args.inscale) + "_denscor_" + str(args.denscor) + "_reduction_" + str(R) + "_acc_" + str(args.acc) + "_" + fname, "w") f.create_dataset("images_ifft_", images.shape, dtype=DTYPE, data=images) f.create_dataset("images_ifft_coils_", images_coils.shape, dtype=DTYPE, data=images_coils) f.create_dataset("CG_reco", result.shape, dtype=DTYPE, data=result) f.create_dataset('InScale', shape=par["InScale"].shape, dtype=DTYPE_real, data=par["InScale"]) f.create_dataset('Bart_ref', shape=img_igrid_sos.shape, dtype=DTYPE, data=img_igrid_sos) f.attrs['res'] = res f.flush() f.close() os.chdir(cwd)
def read_gwf(filename, channels, start=None, end=None, scaled=None, ctype=None, series_class=TimeSeries): """Read a dict of series data from a single GWF file Parameters ---------- filename : `str` the GWF path from which to read channels : `~gwpy.detector.ChannelList`, `list` a list of channels to read from the source. start : `~gwpy.time.LIGOTimeGPS`, `float`, `str` optional GPS start time of required data, anything parseable by :func:`~gwpy.time.to_gps` is fine. end : `~gwpy.time.LIGOTimeGPS`, `float`, `str`, optional GPS end time of required data, anything parseable by :func:`~gwpy.time.to_gps` is fine. scaled : `bool`, optional apply slope and bias calibration to ADC data. type : `dict`, optional a `dict` of ``(name, channel-type)`` pairs, where ``channel-type`` can be one of ``'adc'``, ``'proc'``, or ``'sim'``. series_class : `type`, optional the `Series` sub-type to return. Returns ------- data : `~gwpy.timeseries.TimeSeriesDict` or similar a dict of ``(channel, series)`` pairs read from the GWF file. """ # parse kwargs if not start: start = 0 if not end: end = 0 span = Segment(start, end) # open file stream = io_gwf.open_gwf(filename, 'r') nframes = stream.GetNumberOfFrames() # find channels out = series_class.DictClass() # loop over frames in GWF i = 0 while True: this = i i += 1 # read frame try: frame = stream.ReadFrameNSubset(this, 0) except IndexError: if this >= nframes: break raise # check whether we need this frame at all if not _need_frame(frame, start, end): continue # get epoch for this frame epoch = LIGOTimeGPS(*frame.GetGTime()) # and read all the channels for channel in channels: _scaled = _dynamic_scaled(scaled, channel) try: new = _read_channel(stream, this, str(channel), ctype.get(channel, None), epoch, start, end, scaled=_scaled, series_class=series_class) except _Skip: # don't need this frame for this channel continue try: out[channel].append(new) except KeyError: out[channel] = numpy.require(new, requirements=['O']) # if we have all of the data we want, stop now if all(span in out[channel].span for channel in out): break # if any channels weren't read, something went wrong for channel in channels: if channel not in out: msg = "Failed to read {0!r} from {1!r}".format( str(channel), filename) if start or end: msg += ' for {0}'.format(span) raise ValueError(msg) return out