def plotmap(self,fig,ax): """ This function will plot the map of Alaska. The data will be plotted over it and will use the basemap class to position everything. Input fig - The figure handle for the plots. ax - The axes handle that the map will be plotted over. Output m - This is the handle for the basemap object. """ latlim2 = self.params['latbounds'] lonlim2 = self.params['lonbounds'] m = Basemap(projection='merc',lon_0=sp.mean(lonlim2),lat_0=sp.mean(latlim2),\ lat_ts=sp.mean(latlim2),llcrnrlat=latlim2[0],urcrnrlat=latlim2[1],\ llcrnrlon=lonlim2[0],urcrnrlon=lonlim2[1],\ rsphere=6371200.,resolution='i',ax=ax) # draw coastlines, state and country boundaries, edge of map. #m.drawcoastlines() # m.drawstates() # m.drawcountries() m.readshapefile('st99_d00','states',drawbounds=True) merstep = sp.round_((lonlim2[1]-lonlim2[0])/5.) parstep = sp.round_((latlim2[1]-latlim2[0])/5.) meridians=sp.arange(lonlim2[0],lonlim2[1],merstep) parallels = sp.arange(latlim2[0],latlim2[1],parstep) m.drawparallels(parallels,labels=[1,0,0,0],fontsize=10) m.drawmeridians(meridians,labels=[0,0,0,1],fontsize=10) plt.hold(True) return m
def getCorrection(x, y, x_sv, y_sv): """looks up correction in calculated vector fields""" xi = np.maximum(np.minimum(sp.round_(x / 100).astype('i'), x_sv.shape[0]), 0) yi = np.maximum(np.minimum(sp.round_(y / 100).astype('i'), x_sv.shape[1]), 0) return (x_sv[xi, yi], y_sv[xi, yi])
def deriva(t, z_ode, x, y, z): v_deriva = sp.zeros(len(t)) for pos in range(len(t)): v_deriva[pos] = sp.sqrt( sp.dot((z_ode[pos, :3] - [x[pos], y[pos], z[pos]]), (z_ode[pos, :3] - [x[pos], y[pos], z[pos]]))) v_d = v_deriva / 1000 dist_error = sp.sqrt( sp.dot([x[pos], y[pos], z[pos]], [x[pos], y[pos], z[pos]])) mdistancia = sp.round_(sp.amax(v_d), 1) # distancia máxima entre ambos err = sp.round_(v_deriva[-1] / dist_error, 2) # % de error probando distintos N's #print(f"Error = {err * 100}%") #Gráfico P2 figure(1) title(f"Distancia entre Eulerint y Odeint, d = {mdistancia} [km]") xlabel("Tiempo, t [Horas]") ylabel("Deriva, d [KM]") plot(time, v_d, color="dodgerblue") grid(False) tight_layout() savefig("P4.2.png")
def __expand_points(self, p0, p1, surff) -> list: """ ASCII drawing to come. """ rl = list() # return list p0 = sp.array(p0) p1 = sp.array(p1) dist = sp.linalg.norm(p1[0:2] - p0[0:2]) # 2d distance only # wont append starting point; is endpoint of previous segment; # automatically avoids printing start coordinate to outupt cz = surff(p0[0], p0[1]) # start point depth correction # number of tick points to inspect n = int(sp.ceil(dist/self[self.pt.xysampling])) if n > 1: # tick between start and end points xt = sp.linspace(p0[0], p1[0], n, False) yt = sp.linspace(p0[1], p1[1], n, False) for i in range(1,n): # don't iterate over start/endpoints zi = surff(xt[i], yt[i]) # if new depth correction is too large, if abs(zi - cz) > self[self.pt.zthreshold]: cz = zi di = sp.linalg.norm(sp.array((xt[i], yt[i])) - p0[0:2]) z01= p0[2] + (p1[2]-p0[2])*(di/dist) # interpolate original depth rl.append([float(sp.round_(i, self[self.pt.precision])) for i in [xt[i], yt[i], z01 + cz]]) # append end point cz = surff(p1[0], p1[1]) # start point depth correction rl.append([float(sp.round_(i, self[self.pt.precision])) for i in [p1[0], p1[1], p1[2] + cz]]) return rl
def _hough_transform(img, angles): rows, cols = img.shape # determine the number of bins d = sp.ceil(sp.hypot(*img.shape)) nr_bins = 2 * d bins = sp.linspace(-d, d, nr_bins) # create the accumulator out = sp.zeros((nr_bins, len(angles)), dtype=sp.float64) # compute the sines/cosines cos_theta = sp.cos(angles) sin_theta = sp.sin(angles) # constructe the x and y values y = [] x = [] for i in xrange(rows): y += [i] * cols x += range(cols) y = sp.array(y) x = sp.array(x) # flatten image flattened_img = img.flatten() for i, (c, s) in enumerate(zip(cos_theta, sin_theta)): distances = x * c + y * s bin_indices = (sp.round_(distances) - bins[0]).astype(sp.uint8) bin_sums = sp.bincount(bin_indices, flattened_img) out[:len(bin_sums), i] = bin_sums return out
def makesumrule(ptype,plen,ts,lagtype='centered'): """ This function will return the sum rule. Inputs ptype - The type of pulse. plen - Length of the pulse in seconds. ts - Sample time in seconds. lagtype - Can be centered forward or backward. Output sumrule - A 2 x nlags numpy array that holds the summation rule. """ nlags = sp.round_(plen/ts) if ptype.lower()=='long': if lagtype=='forward': arback=-sp.arange(nlags,dtype=int) arforward = sp.zeros(nlags,dtype=int) elif lagtype=='backward': arback = sp.zeros(nlags,dtype=int) arforward=sp.arange(nlags,dtype=int) else: arback = -sp.ceil(sp.arange(0,nlags/2.0,0.5)).astype(int) arforward = sp.floor(sp.arange(0,nlags/2.0,0.5)).astype(int) sumrule = sp.array([arback,arforward]) elif ptype.lower()=='barker': sumrule = sp.array([[0],[0]]) return sumrule
def makepulse(ptype,plen,ts): """ This will make the pulse array. Inputs ptype - The type of pulse used. plen - The length of the pulse in seconds. ts - The sampling rate of the pulse. Output pulse - The pulse array that will be used as the window in the data formation. plen - The length of the pulse with the sampling time taken into account. """ nsamps = int(sp.round_(plen/ts)) if ptype.lower()=='long': pulse = sp.ones(nsamps) plen = nsamps*ts elif ptype.lower()=='barker': blen = sp.array([1,2, 3, 4, 5, 7, 11,13]) nsampsarg = sp.argmin(sp.absolute(blen-nsamps)) nsamps = blen[nsampsarg] pulse = GenBarker(nsamps) plen = nsamps*ts #elif ptype.lower()=='ac': else: raise ValueError('The pulse type %s is not a valide pulse type.' % (ptype)) return (pulse,plen)
def real2discrete(ds, *real_value): """ 이름 : real2discrete 기능 : 이 함수는 프로젝트 파일에서 real 공간 값으로 선언된 것을 전산모사에서 계산을 할 수 있도록 discrete 한 공간 값으로 변환해 준다. 따라서 주어지는 인자는 한 cell의 최소 단위인 dx가 주어지고, 변환하고자 하는 real 값들을 넣어준다. 인자 : dx, real_vals 반환 : discrete_val 보충 : 들어오는 real 값 개수에 맞추어 결과 discrete 값의 개수도 반환된다. 단지 한 개가 아닌 여러개 인자인 경우 tuple로 반환이 된다. """ number_members = len(real_value) list_discrete_value = [] for mem in xrange(number_members): array_real_value = sc.array(real_value[mem]) array_real_value = array_real_value/ds discrete_value = sc.round_(array_real_value) discrete_value = sc.array(discrete_value,'i') list_discrete_value.append(discrete_value) if len(list_discrete_value) == 1 : return list_discrete_value[0] else: return list_discrete_value
def makesumrule(ptype,plen,ts): nlags = sp.round_(plen/ts) if ptype.lower()=='long': arback = -sp.ceil(sp.arange(0,nlags/2.0,0.5)).astype(int) arforward = sp.floor(sp.arange(0,nlags/2.0,0.5)).astype(int) sumrule = sp.array([arback,arforward]) elif ptype.lower()=='barker': sumrule = sp.array([[0],[0]]) return sumrule
def simulate_common_genotypes(n=1000, m=10000): """ Simulate genotypes """ snps = sp.random.random((m, n)) snps = sp.round_(snps) snps = sp.array(snps, dtype='int8') snps = snps[sp.sum(snps, 1) > 0] print 'Done Simulating SNPs.' return snps
def interpolate(self, canvas, status=None): # Clear the interpolated canvas canvas.interpolated = sp.zeros_like(canvas.fringes_image) - 1024.0 if status is not None: status.set("Performing the interpolation", 70) else: print("Performing the interpolation") # Iterate over all the triangles in the triangulation for triangle in self.triangles: # Create a shortcut to the triangle's vertices co = triangle.vert_coordinates # Calculate a few constants for the Barycentric Coordinates # More info: https://codeplea.com/triangular-interpolation div = (co[1, 0] - co[2, 0]) * (co[0, 1] - co[2, 1]) + ( co[2, 1] - co[1, 1]) * (co[0, 0] - co[2, 0]) a0 = (co[1, 0] - co[2, 0]) a1 = (co[2, 1] - co[1, 1]) a2 = (co[2, 0] - co[0, 0]) a3 = (co[0, 1] - co[2, 1]) # Calculate the bounds of a rectangle that fully encloses # the current triangle xmin = int(sp.amin(triangle.vert_coordinates[:, 1])) xmax = int(sp.amax(triangle.vert_coordinates[:, 1])) + 1 ymin = int(sp.amin(triangle.vert_coordinates[:, 0])) ymax = int(sp.amax(triangle.vert_coordinates[:, 0])) + 1 # Take out slices of the x and y arrays, # containing the points' coordinates x_slice = canvas.x[ymin:ymax, xmin:xmax] y_slice = canvas.y[ymin:ymax, xmin:xmax] # Use Barycentric Coordinates and the magic of numpy (scipy in this # case) to perform the calculations with the C backend, instead # of iterating on pixels with Python loops. # If you have not worked with numpy arrays befor dear reader, # the idea is that if x = [[0 1] # [2 3]], # then x*3+1 is a completely valid operation, returning # x = [[1 4] # [7 10]] # Basically, we can do maths on arrays as if they were variables. # Convenient, and really fast! w0 = (a0 * (x_slice - co[2, 1]) + a1 * (y_slice - co[2, 0])) / div w1 = (a2 * (x_slice - co[2, 1]) + a3 * (y_slice - co[2, 0])) / div w2 = sp.round_(1 - w0 - w1, 10) # Calculate the values for a rectangle enclosing our triangle slice = (self.values[triangle.vertices[0]] * w0 + self.values[triangle.vertices[1]] * w1 + self.values[triangle.vertices[2]] * w2) # Make a mask (so that we only touch the points # inside of the triangle). # In Barycentric Coordinates the points outside of the triangle # have at least one of the coefficients negative, so we use that mask = sp.logical_and(sp.logical_and(w0 >= 0, w1 >= 0), w2 >= 0) # Change the points in the actual canvas canvas.interpolated[ymin:ymax, xmin:xmax][mask] = slice[mask] canvas.interpolation_done = True
def glmnetPlot(x, xvar = 'norm', label = False, ptype = 'coef', **options): import matplotlib.pyplot as plt # process inputs xvar = getFromList(xvar, ['norm', 'lambda', 'dev'], 'xvar should be one of ''norm'', ''lambda'', ''dev'' ') ptype = getFromList(ptype, ['coef', '2norm'], 'ptype should be one of ''coef'', ''2norm'' ') if x['class'] in ['elnet', 'lognet', 'coxnet', 'fishnet']: handle = plotCoef(x['beta'], [], x['lambdau'], x['df'], x['dev'], label, xvar, '', 'Coefficients', **options) elif x['class'] in ['multnet', 'mrelnet']: beta = x['beta'] if xvar == 'norm': norm = 0 nzbeta = beta for i in range(len(beta)): which = nonzeroCoef(beta[i]) nzbeta[i] = beta[i][which, :] norm = norm + scipy.sum(scipy.absolute(nzbeta[i]), axis = 0) else: norm = 0 if ptype == 'coef': ncl = x['dfmat'].shape[0] if x['class'] == 'multnet': for i in range(ncl): mstr = 'Coefficients: Class %d' % (i) handle = plotCoef(beta[i], norm, x['lambdau'], x['dfmat'][i,:], x['dev'], label, xvar, '', mstr, **options) if i < ncl - 1: plt.figure() else: for i in range(ncl): mstr = 'Coefficients: Response %d' % (i) handle = plotCoef(beta[i], norm, x['lambdau'], x['dfmat'][i,:], x['dev'], label, xvar, '', mstr, **options) if i < ncl - 1: plt.figure() else: dfseq = scipy.round_(scipy.mean(x['dfmat'], axis = 0)) coefnorm = beta[1]*0 for i in range(len(beta)): coefnorm = coefnorm + scipy.absolute(beta[i])**2 coefnorm = scipy.sqrt(coefnorm) if x['class'] == 'multnet': mstr = 'Coefficient 2Norms' handle = plotCoef(coefnorm, norm, x['lambdau'], dfseq, x['dev'], label, xvar, '',mstr, **options); else: mstr = 'Coefficient 2Norms' handle = plotCoef(coefnorm, norm, x['lambdau'], x['dfmat'][0,:], x['dev'], label, xvar, '', mstr, **options); return(handle)
def simulate_rare_genotypes(n=1000, m=10000, exp_scale=0.1): """ Simulating unlinked rare genotypes, rounding up exponentially distributed values. m: number of causal variants n: number of individuals """ snps = stats.expon.rvs(0, scale=exp_scale, size=(m, n)) snps = sp.round_(snps) snps[snps > 1] = 1 snps = snps[sp.sum(snps, 1) > 0] print 'Simulated %d dimorphic SNPs' % len(snps) return snps
def doatest(): print("s1 is {}".format(sp.rad2deg(s1_aoa))) print("s2 is {}".format(sp.rad2deg(s2_aoa))) s1_est = music.Estimator(ants, music.covar(s1), nsignals=1) s2_est = music.Estimator(ants, music.covar(s2), nsignals=1) # s1 t1 = time() s1_res = s1_est.doasearch()[0] t1 = time() - t1 s1_err = sp.rad2deg(util.aoa_diff_rad(s1_res, s1_aoa)) #print("s1 estimated value: {} in {}s, error {} deg".format(sp.int_(sp.rad2deg(s1_res)),t1,s1_err)) print("s1 estimated value: {} in {}s, error {} deg".format( sp.round_(sp.rad2deg(s1_res)), t1, s1_err)) #print("s1 estimated value: {} in {}s, error {} deg".format(sp.rad2deg(s1_res),t1,s1_err)) # s2 t2 = time() s2_res = s2_est.doasearch()[0] t2 = time() - t2 s2_err = sp.rad2deg(util.aoa_diff_rad(s2_res, s2_aoa)) print("s2 estimated value: {} in {}s, error {} deg".format( sp.round_(sp.rad2deg(s2_res)), t2, s2_err)) # both signals bothres = est.doasearch()
def readMahalih5(filename,des_site): """ This function will read the mahali GPS data into a GeoData data structure. The user only has to give a filename and name of the desired site. Input filename - A string that holds the file name. des_site - The site name. Should be listed in the h5 file in the table sites. """ h5fn = Path(filename).expanduser() with h5py.File(str(h5fn), "r", libver='latest') as f: despnts = sp.where(f['data']['site']==des_site)[0] # TODO: hard coded for now doy = doy= f['data']['time'][despnts] year = 2015*sp.ones_like(doy,dtype=int) TEC = f['data']['los_tec'][despnts] nTEC = f['data']['err_los_tec'][despnts] vTEC = f['data']['vtec'][despnts] az2sat = f['data']['az'][despnts] el2sat = f['data']['az'][despnts] piercelat = f['data']['pplat'][despnts] piercelong = f['data']['pplon'][despnts] satnum= f['data']['prn'][despnts] recBias = f['data']['rec_bias'][despnts] nrecBias = f['data']['err_rec_bias'][despnts] # Make the integration time on the order of 15 seconds. if (year==year[1]).all(): unixyear =(datetime(year[0],1,1,0,0,0,tzinfo=UTC) - EPOCH).total_seconds() uttime = unixyear + sp.round_(24*3600*sp.column_stack((doy,doy+15./24./3600.))) # Making the difference in time to be a minute else: (y_u,y_iv) = np.unique(year,return_inverse=True) unixyearu = sp.array([(datetime(iy,1,1,0,0,0,tzinfo=UTC) - EPOCH).total_seconds() for iy in y_u]) unixyear = unixyearu[y_iv] uttime = unixyear + 24*3600*sp.column_stack((doy,doy+15./24./3600.)) data = {'TEC':TEC,'nTEC':nTEC,'vTEC':vTEC,'recBias':recBias,'nrecBias':nrecBias,'satnum':satnum,'az2sat':az2sat,'el2sat':el2sat} coordnames = 'WGS84' sensorloc = sp.nan*sp.ones(3) dataloc = sp.column_stack((piercelat,piercelong, 350e3*sp.ones_like(piercelat))) return (data,coordnames,dataloc,sensorloc,uttime)
def get_distribution(list): """Returns al que posible probability distributions for the given list""" size = len(list) x = scipy.arange(size) y = scipy.int_(scipy.round_(scipy.stats.vonmises.rvs(5, size=size) * 255)) plt.figure(1) h = plt.hist(y, bins=range(256), color='w') dist_names = ['gamma', 'beta', 'rayleigh', 'norm', 'rayleigh'] for dist_name in dist_names: dist = getattr(scipy.stats, dist_name) param = dist.fit(y) pdf_fitted = dist.pdf(x, *param[:-2], loc=param[-2], scale=param[-1]) * size plt.plot(pdf_fitted, label=dist_name) plt.xlim(0, 255) plt.legend(loc='upper right') plt.savefig('distribuciones.png', bbox_inches='tight')
def simulate_genotypes(num_indivs=1000, num_snps=1000): """ Simulate genotypes """ snps = sp.random.random((num_snps, num_indivs)) snps = sp.round_(snps) snps = sp.array(snps, dtype='int8') snps = snps[sp.sum(snps, 1) > 0] positions = [] chromosomes = [] for chrom in range(1, 6): len_chrom = num_snps / 5 chromosomes.extend([chrom] * (len_chrom)) positions.extend(range(1, len_chrom + 1)) indiv_ids = range(num_indivs) sd = snpsdata.construct_snps_data_set(snps, positions, chromosomes, indiv_ids) print '\nDone Simulating SNPs.' return sd
def makepulse(ptype,plen,ts): nsamps = sp.round_(plen/ts) if ptype.lower()=='long': pulse = sp.ones(nsamps) plen = nsamps*ts elif ptype.lower()=='barker': blen = sp.array([1,2, 3, 4, 5, 7, 11,13]) nsampsarg = sp.argmin(sp.absolute(blen-nsamps)) nsamps = blen[nsampsarg] pulse = GenBarker(nsamps) plen = nsamps*ts #elif ptype.lower()=='ac': else: raise ValueError('The pulse type %s is not a valide pulse type.' % (ptype)) return (pulse,plen)
def deriva(t, z_ode, z_eul): v_deriva = sp.zeros(len(t)) for pos in range(len(t)): v_deriva[pos] = sp.sqrt( sp.dot((z_ode[pos, :3] - z_eul[pos, :3]), (z_ode[pos, :3] - z_eul[pos, :3]))) v_d = v_deriva / 1000 mdistancia = sp.round_(sp.amax(v_d), 1) #distancia máxima entre ambos #Gráfico P2 figure(2) title(f"Distancia entre Eulerint y Odeint, d = {mdistancia} [km]") xlabel("Tiempo, t [Horas]") ylabel("Deriva, d [KM]") plot(time, v_d, color="dodgerblue") grid(False) tight_layout() savefig("P2.png")
def v2min_image_v(dr, cell, pbc=None, shifts_out=False): """ ------ Authors: matscipy authors - https://github.com/libAtoms/matscipy ------ Apply minimum image convention to an array of distance vectors. Parameters ---------- dr : array_like Array of distance vectors. cell : array_like, shape (n_dim,) Cell extent in each direction. pbc : array_like, optional, type bool Periodic boundary conditions directions. Default is to assume periodic boundaries in all directions. Returns ------- dr : array Array of distance vectors, wrapped according to the minimum image convention. """ # Check where distance larger than 1/2 cell. Particles have crossed # periodic boundaries then and need to be unwrapped. n_dim = len(cell) rec = sp.diag(1. / sp.asarray(cell)) cell = sp.diag(sp.asarray(cell)) if pbc is not None: rec *= sp.array(pbc, dtype=int).reshape(n_dim, 1) dri = sp.round_(sp.dot(dr, rec)) shifts = sp.dot(dri, cell) # Unwrap if shifts_out: return dr - shifts, shifts else: return dr - shifts
def AR_from_C(C, nc, max_order=10): """build covariance sequence for lags [0,max_order+1] from block toeplitz matrix Here the input matrix C is assumed to exhibit a block structure with respect to the multichanneled data and the temporal lag, where the temporal per channel forms the Toeplitz structure, and the multichanneled part the block structure. The output is a sequence of one nc x nc covariance matrix per lag in the toeplitz structure of C. Also the AR coefficients for the order specified """ # inits assert C.shape[0] == C.shape[1], 'C is not square' tf = C.shape[0] / float(nc) assert tf == sp.round_(tf), 'nc does not match tf' tf, nc = int(tf), int(nc) order = min(tf - 1, max_order + 1) print 'doing lags upto:', order gamma_y = sp.zeros((order, nc, nc)) GammaY0 = sp.empty(((order - 1) * nc, (order - 1) * nc)) # build gamma_y_seq from C for o in xrange(order): for c1 in xrange(nc): for c2 in xrange(nc): gamma_y[o, c1, c2] = C[c1 * tf + o, c2 * tf] # build GammaY0 from gamma_y_seq, blockwise for i in xrange(order - 1): for j in xrange(i, order - 1): GammaY0[i * nc:(i + 1) * nc, j * nc:(j + 1) * nc] = gamma_y[j - i] if j > i: GammaY0[j * nc:(j + 1) * nc, i * nc:(i + 1) * nc] = gamma_y[j - i].T # build calculation matrices GammaY0inv = sp_la.inv(GammaY0) gamma_y_seq = sp.hstack(gamma_y[1:]) # return return sp.dot(gamma_y_seq, GammaY0inv), gamma_y
def trainModel(self, do_pca = False,out_dir='./cache', rftop = 40, class_labels = SP.array(['G1','S','G2M']), cv=10, npc=3, is_SVM=1, is_RFE=0 , scale=False): if not os.path.exists(out_dir): os.makedirs(out_dir) CFG = {} CFG['is_RFE'] = is_RFE # use recursive feature selection (can be slow for large datasets) CFG['is_SVM'] = is_SVM # use SVM with univariate feature selection (faster than RFE) CFG['CV_inner'] = cv #inner CV for RFE_CV: either an int or 'LOOCV' CFG['out_dir'] = out_dir CFG['do_pca'] = do_pca CFG['lassotop'] = 20 self.cv = cv Y = self.Y labels = self.labels var_names = self.geneNames numClasses = self.numClasses predRF = SP.zeros((len(labels),numClasses)) predSVM = SP.zeros((len(labels),numClasses)) predSVMrbf = SP.zeros((len(labels),numClasses)) predGNB = SP.zeros((len(labels),numClasses)) predLR = SP.zeros((len(labels),numClasses)) predLRall = SP.zeros((len(labels),numClasses)) names_dict={} if self.cv == 'LOOCV': loo = LeaveOneOut(len(labels)) CV_list = (list(iter(loo))) CV_list.append((SP.array(range(Y.shape[0])), SP.array(range(Y.shape[0]))))#all data... else: skf = StratifiedKFold(labels, n_folds=self.cv) CV_list = (list(iter(skf))) CV_list.append((SP.array(range(Y.shape[0])), SP.array(range(Y.shape[0]))))#all data... lambda_best = SP.zeros((1,len(CV_list))).ravel() print("Performing cross validation ...") for i in range(len(CV_list)): if i<len(CV_list)-1: print("Fold " + str(i+1) + " of " + str(len(CV_list)-1)) else: print("Final model") # string label for this fold #get data of a CV run cv_tr = CV_list[i][0] cv_tst = CV_list[i][1] lab_tr = labels[cv_tr] Ytr = Y[cv_tr,:] Ytst = Y[cv_tst,:] lab_tst = labels[cv_tst] if (i==len(CV_list)-1): foldlabel = 'full' if (self.Y_tst==None): Ytst = Y[cv_tst,:] lab_tst = labels[cv_tst] else: foldlabel = 'Test' Ytst = self.Y_tst lab_tst = self.labels_tst else: foldlabel = str(i) if do_pca>=1: npc = npc#3 #do PCA to get features pcaCC = PCA(n_components=npc, whiten=False) pcaCC.fit(Ytr) pcaTst=pcaCC.transform(Ytst) pcaTr=pcaCC.transform(Ytr) #selection = SelectKBest(k=1) #combined_features = FeatureUnion([("pca", pcaCC), ("univ_select", selection)]) combined_features = FeatureUnion([("pca", pcaCC)]) gnb = GaussianNB() y_pred = gnb.fit(pcaTr, lab_tr).predict_proba(pcaTst) if i<len(CV_list)-1: predGNB[cv_tst,:] =y_pred#[:,1] else: predGNB_ts = y_pred#[:,1] if do_pca==2: Ytr = SP.concatenate((Ytr, pcaTr),1) Ytst = SP.concatenate((Ytst, pcaTst),1) pcnames = [] for pci in range(npc): pcnames.append('PC'+str(pci+1)) var_names = SP.concatenate((var_names, SP.array(pcnames)),1) print(" Computing random forest ...") if CFG['is_RFE']==1:#Recursive feature selection with SVM print(" Computing RFE with SVM ...") svc = SVC(kernel="linear", probability=False, class_weight='auto')#use linear SVM for selection rfecv = RFECV(estimator=svc, step=1,scoring='f1') param_grid = dict(estimator__C=[0.1, 1, 10, 100, 1000]) clf_rfe = GridSearchCV(rfecv, param_grid=param_grid, cv=3, scoring='f1')#GridSearch to find optimal parameters clf_rfe.fit(Ytr, lab_tr) svc = SVC(kernel="linear", probability=False,C=clf_rfe.best_estimator_.estimator.C, class_weight='auto')#use linear SVM for selection if CFG['CV_inner']=='': rfecv = RFECV(estimator=svc, step=1,scoring='f1') elif CFG['CV_inner']=='LOOCV': rfecv = RFECV(estimator=svc, step=1,scoring='f1', cv=LeaveOneOut(len(lab_tr))) else: rfecv = RFECV(estimator=svc, step=1,scoring='f1', cv=StratifiedKFold(lab_tr, n_folds=CFG['CV_inner'])) clf_rfe.best_estimator_.fit(Ytr, lab_tr) predicted = clf_rfe.best_estimator_.predict(Ytst) if i<len(CV_list)-1: predSVM[cv_tst,:] = predicted else: predSVM_ts[cv_tst] = predicted classifier = svm.SVC(kernel='rbf', gamma=0.05, class_weight='auto', probability=True)#rbf kernel for prediction param_grid = dict(C=[0.1, 1], gamma=[1e-1,1e-2,1e-3]) clf_rbf = GridSearchCV(classifier, param_grid=param_grid, cv=3, scoring='f1') clf_rbf.fit(Ytr[:,clf_rfe.best_estimator_.ranking_==1], lab_tr) clf_rbf.best_estimator_.fit(Ytr[:,clf_rfe.best_estimator_.ranking_==1], lab_tr) predicted = clf_rbf.best_estimator_.predict_proba(Ytst[:,clf_rfe.best_estimator_.ranking_==1]) if i<len(CV_list)-1: predSVMrbf[cv_tst,:] = predicted fpr, tpr, thresholds = metrics.roc_curve(lab_tst, predicted[:,1]) if (i==len(CV_list)-1) | CFG["CV_plots"]>0: PL.figure() PL.plot(fpr, tpr) PL.savefig(CFG['out_dir']+'/RF_SVM_'+foldlabel+'.pdf') names_dict[foldlabel+'_SVM']=self.geneNames[clf_rfe.best_estimator_.ranking_==1] elif CFG['is_SVM']==1:#univariate FS with rbf SVM; choose this if you hava a large data set (many features, eg RNAseq) print(" SVM feature selection ...") classifier = svm.SVC(kernel='rbf', gamma=0.05, class_weight='auto', probability=True) selection = SelectKBest(k=1) combined_features = FeatureUnion([("univ_select", selection)]) X_features = combined_features.fit(Ytr, lab_tr).transform(Ytr) scaler = preprocessing.StandardScaler().fit(Ytr) YtrS = scaler.transform(Ytr) YtstS = scaler.transform(Ytst) classifier.fit(X_features, lab_tr) pipeline = Pipeline([("features", combined_features), ("svm", classifier)]) if CFG['do_pca']==3: param_grid = dict(features__pca__n_components=SP.unique(SP.round_(SP.logspace(1.0,max(SP.log2(Ytr.shape[1]), SP.log2(10)),num=min(5,Ytr.shape[1]),base=2.0))), features__univ_select__k=SP.unique(SP.round_(SP.logspace(3.0,SP.log2(Ytr.shape[1]),num=min(10,Ytr.shape[1]),base=2.0))), svm__C=[0.1, 1, 10], svm__gamma=[1e-1,1e-2,1e-3]) else: C_range = 10. ** SP.arange(0, 2) gamma_range = 10. ** SP.arange(-5, 1) param_grid = dict(features__univ_select__k=SP.unique(SP.round_(SP.logspace(3.0,SP.log2(Ytr.shape[1]),num=min(10,Ytr.shape[1]),base=2.0))), svm__C=C_range, svm__gamma=gamma_range) clf = GridSearchCV(pipeline, param_grid=param_grid, cv=5, scoring='f1') clf.fit(YtrS, lab_tr) print("The best classifier is: ", clf.best_estimator_) select_best=clf.best_estimator_.get_params()['features__univ_select'] #names_dict[foldlabel+'_SVM']=self.geneNames[SP.argsort(-1.0*select_best.scores_)[0:(select_best.k-1)]] expected = lab_tst predicted = clf.best_estimator_.predict_proba(YtstS) if i<len(CV_list)-1: predSVM[cv_tst,:] = predicted else: predSVM_ts = predicted #print(clf.best_estimator_) classifier = svm.SVC(kernel='rbf', gamma=0.05, class_weight='auto', probability=True)#rbf kernel for prediction param_grid = dict(C=[1,10], gamma=[ 1e-1,1e-2,1e-3]) clf_rbf = GridSearchCV(classifier, param_grid=param_grid, cv=5, scoring='f1') clf_rbf.fit(Ytr, lab_tr) clf_rbf.best_estimator_.fit(Ytr, lab_tr) predicted = clf_rbf.best_estimator_.predict_proba(Ytst) if i<len(CV_list)-1: predSVMrbf[cv_tst,:] = predicted else: predSVMrbf_ts = predicted #do lasso with regularisation path cs = l1_min_c(Ytr, lab_tr, loss='log') * SP.logspace(0, 3) print(" Computing regularization path ...") lasso = linear_model.LogisticRegression(C=cs[0]*10.0, penalty='l1', tol=1e-6) param_grid = dict(C=cs) clf_lr = GridSearchCV(lasso, param_grid=param_grid, cv=5, scoring='f1') clf_lr.fit(Ytr, lab_tr) clf_lr.best_estimator_.fit(Ytr, lab_tr) lambda_best[i] = clf_lr.best_params_.get('C') predicted = clf_lr.best_estimator_.predict_proba(Ytst) clf = linear_model.LogisticRegression(C=cs[0]*10.0, penalty='l1', tol=1e-6) coefs_ = [] for c in cs: clf.set_params(C=c) clf.fit(Ytr, lab_tr) coefs_.append(clf.coef_.ravel().copy()) if i<len(CV_list)-1: predLR[cv_tst,:] = predicted else: predLR_ts = predicted coefs_ = SP.array(coefs_) # get ordering by importance (how many times they appear) order=(coefs_!=0).sum(axis=0).argsort() order=order[::-1] # descending # store this order featrank_lasso = order showtop= min(Ytr.shape[1], CFG['lassotop']) clfAll = linear_model.LogisticRegression(C=1e5, penalty='l2', tol=1e-6) clfAll.fit(Ytr, lab_tr) predicted = clfAll.predict_proba(Ytst) if i<len(CV_list)-1: predLRall[cv_tst,:] = predicted else: predLRall_ts = predicted forest = ExtraTreesClassifier(n_estimators=500, random_state=0, criterion="entropy", bootstrap=False) #forest = RandomForestClassifier(n_estimators=500, # random_state=0, criterion="entropy") forest.fit(Ytr, lab_tr) pred = forest.predict_proba(Ytst) #pdb.set_trace() if i<len(CV_list)-1: predRF[cv_tst,:] = pred#[:,1] else: predRF_ts = pred#[:,1] importances = forest.feature_importances_ std = SP.std([tree.feature_importances_ for tree in forest.estimators_], axis=0) topfeat=min(Ytr.shape[1], rftop) indices = SP.argsort(importances)[::-1][0:topfeat] # store full feature ranking featrank_rf = SP.argsort(importances)[::-1] # Plot the feature importances of the forest if (i==len(CV_list)-1): PL.figure() #PL.title("Feature importances, Fold "+foldddPPlabel+', AUC='+str(SP.round_(metrics.auc(fpr, tpr),3))) PL.title("Feature importances") #PL.bar(range(topfeat), importances[indices],color="r", yerr=std[indices], align="center") PL.bar(range(topfeat), importances[indices],color="r", align="center") PL.xticks(range(topfeat), indices, rotation=70) PL.gca().set_xticklabels(var_names[indices]) PL.setp(PL.gca().get_xticklabels(), fontsize=8) PL.xlim([-1, topfeat]) PL.savefig(out_dir+'/RF_featureimportance_'+foldlabel+'.pdf') f2 = open(os.path.join(out_dir,'classification_reportCV.txt') ,'w') predRFv = SP.argmax(predRF_ts,axis=1)+1 predRF_trv = SP.argmax(predRF,axis=1)+1 self.scores = predRF self.scores_tst = predRF_ts self.ranking = var_names[indices] predLRv = SP.argmax(predLR_ts,axis=1)+1 predLR_trv = SP.argmax(predLR,axis=1)+1 self.scoresLR = predLR self.scoresLR_tst = predLR_ts predLRallv = SP.argmax(predLRall_ts,axis=1)+1 predLRall_trv = SP.argmax(predLRall,axis=1)+1 self.scoresLRall = predLRall self.scoresLRall_tst = predLRall_ts if CFG['is_SVM']==1: predSVMv = SP.argmax(predSVM_ts,axis=1)+1 predSVM_trv = SP.argmax(predSVM,axis=1)+1 self.scoresSVM = predSVM self.scoresSVM_tst = predSVM_ts predSVMrbfv = SP.argmax(predSVMrbf_ts,axis=1)+1 predSVMrbf_trv = SP.argmax(predSVMrbf,axis=1)+1 self.scoresSVMrbf = predSVMrbf self.scoresSVMrbf_tst = predSVMrbf_ts predGNBv = SP.argmax(predGNB_ts,axis=1)+1 predGNB_trv = SP.argmax(predGNB,axis=1)+1 self.scoresGNB = predGNB self.scoresGNB_tst = predGNB_ts print("Classification report for classifier %s:\n%s\n" % ('Gaussian Naive Bayes', metrics.classification_report(self.labels, predGNB_trv))) print("Classification report for classifier %s:\n%s\n" % ('Random Forest', metrics.classification_report(self.labels, predRF_trv))) print("Classification report for classifier %s:\n%s\n" % ('LR', metrics.classification_report(self.labels, predLR_trv))) print("Classification report for classifier %s:\n%s\n" % ('LRall', metrics.classification_report(self.labels, predLRall_trv))) if CFG['is_RFE']==1: print("Classification report for classifier %s:\n%s\n" % ('SVM ', metrics.classification_report(labels, predSVM>0.5)),file=f2) elif CFG['is_SVM']==1: print("Classification report for classifier %s:\n%s\n" % ('SVM', metrics.classification_report(self.labels, predSVM_trv))) print("Classification report for classifier %s:\n%s\n" % ('SVMrbf', metrics.classification_report(self.labels, predSVMrbf_trv))) f2.close()
def plotPerformance(self,perfType = 'ROC',plot_test=True, out_dir = './cache',class_labels = ['G1 phase','S phase','G2M phase'], method = 'RF'): plparams = {'backend': 'pdf', 'axes.labelsize': 14, 'text.fontsize': 14, 'legend.fontsize': 13, 'xtick.labelsize': 14, 'ytick.labelsize': 14, 'text.usetex': False} PL.rcParams.update(plparams) assert(perfType in ['ROC', 'PR']) if plot_test ==True: if method=='RF': labs = self.labels_tst scores = self.scores_tst elif method=='LR': labs = self.labels_tst scores = self.scoresLR_tst elif method=='LRall': labs = self.labels_tst scores = self.scoresLRall_tst elif method=='GNB': labs = self.labels_tst scores = self.scoresGNB_tst elif method=='SVM': labs = self.labels_tst scores = self.scoresSVM_tst elif method=='SVMrbf': labs = self.labels_tst scores = self.scoresSVMrbf_tst else: if method=='RF': labs = self.labels scores = self.scores elif method=='LR': labs = self.labels scores = self.scoresLR elif method=='LRall': labs = self.labels scores = self.scoresLRall elif method=='GNB': labs = self.labels scores = self.scoresGNB elif method=='SVM': labs = self.labels scores = self.scoresSVM elif method=='SVMrbf': labs = self.labels scores = self.scoresSVMrbf PL.figure() #col = ['r', 'b', 'g'] col = ['#1b9e77', '#d95f02', '#7570b3'] aucList = SP.zeros((scores.shape[1],)) for ind in range(scores.shape[1]): labels_i = labs.copy() scores_i = scores[:,ind] labels_i[labs==ind+1] = 1 labels_i[labs!=ind+1] = 0 if perfType == 'ROC': fpr, tpr, thresholds = metrics.roc_curve(labels_i, scores_i) aucList[ind] = metrics.auc(fpr, tpr) elif perfType == 'PR': fpr, tpr, thresholds = metrics.precision_recall_curve(labels_i, scores_i) PL.plot(fpr, tpr, '-', c=col[ind]) if perfType=='ROC': PL.title("ROC curve ccClassify") PL.xlabel('FPR') PL.ylabel('TPR') leg_str = list() for i in range(len(class_labels)): leg_str.append(class_labels[i]+', AUC = '+str(SP.round_(aucList[i],3))) PL.legend(leg_str, loc='lower-right') ax = plt.gca() ax.spines["right"].set_visible(False) ax.spines["top"].set_visible(False) ax.get_xaxis().tick_bottom() ax.get_yaxis().tick_left() PL.savefig(out_dir+'/ROC_test'+str(plot_test)+'_'+method+'.pdf',bbox_inches='tight') else: PL.title("PR curve ccClassify") PL.xlabel('Precision') PL.ylabel('Recall') leg_str = list() for i in range(len(class_labels)): leg_str.append(class_labels[i])#+', AUC = '+str(SP.round_(aucList[i],3))) PL.legend(leg_str, loc='lower-right') ax = plt.gca() ax.spines["right"].set_visible(False) ax.spines["top"].set_visible(False) ax.get_xaxis().tick_bottom() ax.get_yaxis().tick_left() PL.savefig(out_dir+'/ROC_test'+str(plot_test)+'_'+method+'.pdf',bbox_inches='tight')
def refresh_table(request, option_name): try: #print " ------------------------------------------------------------------------------ " #print request.POST #print " ------------------------------------------------------------------------------ " #print request.is_ajax() #print " ------------------------------------------------------------------------------ " if request.is_ajax() and request.POST: option_name = request.POST['option_name'] options = OptionDefinition.objects.all() option = [o for o in options if o.name == option_name][0] optioncontracts = sorted( OptionContract.objects.filter(optiondefinition_id=option.id), key = lambda x : x.strike) published_options = sorted( PublishOptionContract.objects.filter(optiondefinition_id=option.id), key = lambda x : x.strike) future = option.future today = datetime.date.today() time2expiry = hf.diff_dates_year_fraction(option.expiry_date, today) # we need to know the last vol to calculate the change, we store this in a dict # accessed by strike value published_options_dict = dict([(i.strike, i.vol) for i in published_options]) published_options_changes_dict = dict([(i.strike, i.change) for i in published_options]) strikes = [float(i) for i in request.POST.getlist('strikes[]')] #json_strikes = json.dumps(strikes) vols = [float(i) for i in request.POST.getlist('vols[]')] call_values = [hf.black_pricer(time2expiry, future.bid, K, v, call = True) for K, v in zip(strikes, vols)] put_values = [hf.black_pricer(time2expiry, future.bid, K, v, call = False) for K, v in zip(strikes, vols)] call_deltas = [hf.black_delta(time2expiry, future.bid, K, v, call = True) for K, v, in zip(strikes, vols)] # extra stuff Gareth wants put_delta = [hf.black_delta(time2expiry, future.bid, K, vol, call = False) for K, vol in zip(strikes, vols)] value_gamma = [hf.black_gamma(time2expiry, future.bid, K, vol) for K, vol in zip(strikes, vols)] value_theta = [hf.black_theta(time2expiry, future.bid, K, vol) for K, vol in zip(strikes, vols)] value_vega = [hf.black_vega(time2expiry, future.bid, K, vol) for K, vol in zip(strikes, vols)] changes = [] # if we're updating on a publish table event we just want the changes from the db, this is because # the db gets changed before we update the table, therefore when we query the db to find what the # old vols were, because we've just changed them, they're the same as the new. if request.POST['update'] == 'gradeX': for s, v in zip(strikes, vols): changes.append(published_options_changes_dict[s]) # if we're updated on an update table event, then we need to calculate the changes else: for s, v in zip(strikes, vols): if s in published_options_dict: changes.append(v - published_options_dict[s]) else: changes.append(0.0) #print changes heading_row = [future.name, option.name, future.bid] atm_strike = hf.ATM_strike(strikes, future.bid) random_column = [] for pos, (v, s) in enumerate(zip(vols, strikes)): if s == atm_strike: random_column.append(scipy.round_(hf.black_pricer(time2expiry, future.bid, s, v, call = True) + hf.black_pricer(time2expiry, future.bid, s, v, call = False), decimals = 5)) else: random_column.append('') return HttpResponse(json.dumps({ 'strikes' : strikes, 'call_values' : [scipy.round_(i, decimals=5) for i in call_values], 'put_values' : [scipy.round_(i, decimals=5) for i in put_values], 'call_deltas' : [scipy.round_(i, decimals=5) for i in call_deltas], 'put_deltas' : [scipy.round_(i, decimals=5) for i in put_delta], 'value_gamma' : [scipy.round_(i, decimals=5) for i in value_gamma], 'value_theta' : [scipy.round_(i, decimals=5) for i in value_theta], 'value_vega' : [scipy.round_(i, decimals=5) for i in value_vega], 'vols' : [scipy.round_(i, decimals=5) for i in vols], 'changes' : [scipy.round_(i, decimals=5) for i in changes], 'random_column' : random_column, 'heading_row' : heading_row, }), mimetype="application/json" ) else: #print "else raise" raise Http404 except Exception as e: #print e raise Http404
# -*- coding: utf-8 -*- """ Created on Wed Jun 19 00:00:01 2013 ╛ @author: jhinebaugh """ import OpenPNM from time import clock import scipy as sp clock() print 'Creating 25,000 pore cubic network' cubic = OpenPNM.Geometry.Cubic().generate(domain_size=[50,50,10],lattice_spacing=[1.0]) print 'Finished at time =',sp.round_(clock(),2),'seconds' print '' print 'Creating 100 pore Delauny network' delaunay = OpenPNM.Geometry.Delaunay().generate(domain_size=[10,10,10],num_pores=100) print 'Finished at time =',sp.round_(clock(),2),'seconds' print '' print 'Creating #### pore imported network' matfile = OpenPNM.Geometry.MatFile().generate(filename='standard_cubic_5x5x5.mat') print matfile print 'Finished at time =',sp.round_(clock(),2),'seconds' print '' print "Adding 'air' and 'water' for each network type" air_cubic = OpenPNM.Fluids.Air().create(fluid_name='air_cubic') water_cubic = OpenPNM.Fluids.Water().create(fluid_name='water_cubic') air_delaunay = OpenPNM.Fluids.Air().create(fluid_name='air_delaunay') water_delaunay = OpenPNM.Fluids.Water().create(fluid_name='water_delaunay') air_matfile = OpenPNM.Fluids.Air().create(fluid_name='air_matfile') water_matfile = OpenPNM.Fluids.Water().create(fluid_name='water_matfile')
def option(request, option_name): try: options = OptionDefinition.objects.all() option = [o for o in options if o.name == option_name][0] optioncontracts = sorted( OptionContract.objects.filter(optiondefinition_id=option.id), key = lambda x : x.strike) strikes = [o.strike for o in optioncontracts] bids = [o.bid if o.bid > 0 else None for o in optioncontracts] json_strikes = json.dumps(strikes) json_bids = json.dumps(bids) asks = [o.ask if o.ask > 0 else None for o in optioncontracts] json_asks = json.dumps(asks) values = [o.value if o.value > 0 else None for o in optioncontracts] json_values = json.dumps(values) bid_volume = json.dumps([o.bid_volume if o.bid_volume > 0 else None for o in optioncontracts]) ask_volume = json.dumps([o.ask_volume if o.ask_volume > 0 else None for o in optioncontracts]) last_trade_value = [o.last_trade_value if o.last_trade_value > 0 else None for o in optioncontracts] json_last_trade_value = json.dumps(last_trade_value) last_trade_volume = json.dumps([o.last_trade_volume if o.last_trade_volume > 0 else None for o in optioncontracts]) last_updated = json.dumps([o.last_updated.strftime("%Y-%m-%d %H:%M:%S") for o in optioncontracts]) #get future price future = option.future callbool = [True if o.easy_screen_mnemonic[-3] == 'c' else False for o in optioncontracts] today = datetime.date.today() time2expiry = hf.diff_dates_year_fraction(option.expiry_date, today) # calc vols and deltas bid_vols = [hf.black_pricer_vol(time2expiry, future.bid, K, Val, call) for K, Val, call in zip(strikes, bids, callbool)] json_bid_vols = json.dumps(bid_vols) bid_delta = [hf.black_delta(time2expiry, future.bid, K, vol, call) for K, vol, call in zip(strikes, bid_vols, callbool)] json_bid_delta = json.dumps(bid_delta) # always future.bid. Why? you can't hedge against a price future price that don't exist, so we don't use the value. We # therefore need to choose one of bid or ask. We choose bid. ask_vols = [hf.black_pricer_vol(time2expiry, future.bid, K, Val, call) for K, Val, call in zip(strikes, asks, callbool)] json_ask_vols = json.dumps(ask_vols) # always future.bid. Why? you can't hedge against a price future price that don't exist, so we don't use the value. We # therefore need to choose one of bid or ask. We choose bid. ask_delta = json.dumps([hf.black_delta(time2expiry, future.bid, K, vol, call) for K, vol, call in zip(strikes, ask_vols, callbool)]) # always future.bid. Why? you can't hedge against a price future price that don't exist, so we don't use the value. We # therefore need to choose one of bid or ask. We choose bid. value_vols = [hf.black_pricer_vol(time2expiry, future.bid, K, Val, call) for K, Val, call in zip(strikes, values, callbool)] #interpolate on vol surface. Presently order 3 spline. value_vols = hf.spline_interpolate(value_vols, strikes) json_value_vols = json.dumps(value_vols) # always future.bid. Why? you can't hedge against a price future price that don't exist, so we don't use the value. We # therefore need to choose one of bid or ask. We choose bid. value_delta = [hf.black_delta(time2expiry, future.bid, K, vol, call) for K, vol, call in zip(strikes, value_vols, callbool)] json_value_delta = json.dumps(value_delta) # always future.bid. Why? you can't hedge against a price future price that don't exist, so we don't use the value. We # therefore need to choose one of bid or ask. We choose bid. call_delta = [hf.black_delta(time2expiry, future.bid, K, vol, call = True) for K, vol in zip(strikes, value_vols)] last_trade_vols = [hf.black_pricer_vol(time2expiry, future.last_trade_value, K, Val, call) for K, Val, call in zip(strikes, last_trade_value, callbool)] json_last_trade_vols = json.dumps(last_trade_vols) last_trade_delta = json.dumps([hf.black_delta(time2expiry, future.last_trade_value, K, vol, call) for K, vol, call in zip(strikes, last_trade_vols, callbool)]) # extra stuff Gareth wants put_delta = [hf.black_delta(time2expiry, future.bid, K, vol, call = False) for K, vol in zip(strikes, value_vols)] value_gamma = [hf.black_gamma(time2expiry, future.bid, K, vol) for K, vol in zip(strikes, value_vols)] value_theta = [hf.black_theta(time2expiry, future.bid, K, vol) for K, vol in zip(strikes, value_vols)] value_vega = [hf.black_vega(time2expiry, future.bid, K, vol) for K, vol in zip(strikes, value_vols)] publishedcontracts = sorted( PublishOptionContract.objects.filter(optiondefinition_id=option.id), key = lambda x : x.strike) if len(publishedcontracts) == 0: published = False published_time = json.dumps(datetime.datetime(1900,1,1,0,0,0).strftime("%Y-%m-%d %H:%M:%S")) table_data = []#(future.name, option.month_tag, future.bid, '', '', '', '', '')] atm_strike = hf.ATM_strike(strikes, future.bid) random_column = [] for pos, (v, s) in enumerate(zip(value_vols, strikes)): if s == atm_strike: random_column.append(scipy.round_(hf.black_pricer(time2expiry, future.bid, s, v, call = True) + hf.black_pricer(time2expiry, future.bid, s, v, call = False), decimals = 5)) else: random_column.append('') for p in xrange(len(random_column)): table_data.append( ( scipy.round_(strikes[p], decimals=5), scipy.round_(hf.black_pricer(time2expiry, future.bid, strikes[p], value_vols[p], True), decimals=5), scipy.round_(hf.black_pricer(time2expiry, future.bid, strikes[p], value_vols[p], False), decimals=5), random_column[p], scipy.round_(call_delta[p], decimals=5), scipy.round_(put_delta[p], decimals=5), scipy.round_(value_gamma[p], decimals=5), scipy.round_(value_theta[p], decimals=5), scipy.round_(value_vega[p], decimals=5), scipy.round_(value_vols[p], decimals=5), '-' ) ) else: # here we need to get stuff from the publishedcontracts published = True published_time = publishedcontracts[0].publish_time table_data = []#(future.name, option.month_tag, publishedcontracts[0].future_value, '', '', '', '', '')] atm_strike = hf.ATM_strike([c.strike for c in publishedcontracts], publishedcontracts[0].future_value) time2expiry = hf.diff_dates_year_fraction(option.expiry_date, publishedcontracts[0].publish_time) random_column = [] for pos, o in enumerate(publishedcontracts): if o.strike == atm_strike: random_column.append(scipy.round_(hf.black_pricer(time2expiry, o.future_value, o.strike, o.vol, call = True) + hf.black_pricer(time2expiry, o.future_value, o.strike, o.vol, call = False), decimals = 5)) else: random_column.append('') for pos, c in enumerate(publishedcontracts): table_data.append( ( scipy.round_(c.strike, decimals=5), scipy.round_(c.call_value, decimals=5), scipy.round_(c.put_value, decimals=5), random_column[pos], scipy.round_(c.call_delta, decimals=2), scipy.round_(c.put_delta, decimals=2), scipy.round_(c.gamma, decimals=3), scipy.round_(c.theta, decimals=2), scipy.round_(c.vega, decimals=2), scipy.round_(c.vol, decimals=5), scipy.round_(c.change, decimals=5), ) ) except Exception as e: #print e #raise Http404 return render( request, 'marketdata/no-data-option.html', { 'option': option, }) return render( request, 'marketdata/option.html', { 'future': future, 'future_bid': future.bid, 'future_last_updated': future.last_updated, 'option': option, 'strikes' : json_strikes, 'non_json_strikes' : strikes, 'bids' : json_bid_vols, 'bids_delta' : json_bid_delta, 'asks' : json_ask_vols, 'asks_delta' : ask_delta, 'values' : json_value_vols, 'values_delta' : json_value_delta, 'bid_volume' : bid_volume, 'ask_volume' : ask_volume, 'last_trade_value' : json_last_trade_vols, 'last_trade_volume' : last_trade_volume, 'last_updated' : last_updated, 'published' : published, 'published_time' : published_time, 'table_data' : table_data } )
def get_ramp(x0, x1, vmax, a, dt, output='ramp only'): """ Generate a ramp trajectory from x0 to x1 with constant acceleration, a, to maximum velocity v_max. Note, the main purlpose of this routine is to generate a trajectory from x0 to x1. For this reason v_max and a are adjusted slightly to work with the given time step. Arguments: x0 = starting position x1 = ending position vmax = maximum allowed velocity a = constant acceleration Keywords: output = 'ramp only' or 'full' when ramp only is selected then only the velocity ramp is returned. If 'full' is selected the adjusted acceleration and maximum velocity are also returned. Ouput: ramp = ramp trajectory form x0 to x1 """ # Insure we are dealing with floating point numbers x0, x1 = float(x0), float(x1) vmax, a = float(vmax), float(a) dt = float(dt) vmax, a = abs(vmax), abs(a) # Make sure that v_max and a are positive # Check to see if there is anything to do if x0 == x1: return scipy.array([x0]) # Get distance and sign indicating direction dist = abs(x1 - x0) sign = scipy.sign(x1 - x0) # Determine if we will reach v_max t2vmax = vmax / a t2halfdist = scipy.sqrt(0.5 * dist / a) if t2vmax > t2halfdist: # Trajectory w/o constant velocity segment T = scipy.sqrt(dist / a) n = int(scipy.round_((1.0 / dt) * T)) # Adjust accel and duration for rounding of n (discrete time steps) a = dist / (n * dt)**2 T = scipy.sqrt(dist / a) # Generate trajectory t = scipy.linspace(0.0, 2.0 * T, 2 * n + 1) def f1(t): return 0.5 * sign * a * (t**2) def f2(t): s = t - T return f1(T) + sign * a * T * s - 0.5 * sign * a * s**2 func_list = [f1, f2] cond_list = [t <= T, t > T] ramp = x0 + scipy.piecewise(t, cond_list, func_list) else: # Trajectory w/ constant velocity segment # Compute acceleration time and adjust acceleration T1 = vmax / a n = int(scipy.round_(T1 / dt)) a = vmax / (n * dt) # Adjusted acceleration T1 = vmax / a # Adjusted acceleration time # Compute and adjust constant velocity time T2 = dist / vmax - T1 m = int(scipy.round_(T2 / dt)) vmax = dist / (dt * (n + m)) # Adjusted max velocity T2 = dist / vmax - T1 # Adjusted constant velocity time # Generate trajectory t = scipy.linspace(0.0, 2.0 * T1 + T2, 2 * n + m + 1) def f1(t): return 0.5 * sign * a * (t**2) def f2(t): s = t - T1 return f1(T1) + sign * vmax * s def f3(t): s = t - T1 - T2 return f2(T1 + T2) + sign * vmax * s - 0.5 * sign * a * s**2 func_list = [f1, f2, f3] cond_list = [ t <= T1, scipy.logical_and(t > T1, t <= T1 + T2), t > T1 + T2 ] ramp = x0 + scipy.piecewise(t, cond_list, func_list) if output == 'ramp only': return ramp elif output == 'full': return ramp, vmax, a else: raise ValueError, 'unknown keyword option output=%s' % (output, )
print '\nwithout using cache' print tn, '(*n)' print '\n2nd\t4th\t6th\t8th\t(spatial order)' print '1D' for n, nx in [(256, 256), (512, 512)]: print '(%d=%d)' % (n, nx) n2 = 6 * n + 3 * n + (2 * n + 1) + (2 * n + 1) n4 = 6 * n + 7 * n + (4 * n + 3) + (4 * n + 3) n6 = 6 * n + 11 * n + (6 * n + 5) + (6 * n + 5) n8 = 6 * n + 15 * n + (8 * n + 7) + (8 * n + 7) #rn = 6.*n + (2*p-1)*n + (p*n+p-1) + (p*n+p-1) rn = 6. * n + (4 * p - 1) * n + 2 * (p - 1) #print rn ratio = rn / (tn * n) * 100 print sc.round_(ratio, 2), '%' print '\n2D' for n, nx, ny in [(256, 16, 16), (512, 32, 16)]: print '(%d=%dx%d)' % (n, nx, ny) n2 = 6 * n + (2 * n + nx) + (2 * n + ny) + (n + (nx + ny)) n4 = 6 * n + (4 * n + 3 * nx) + (4 * n + 3 * ny) + (n + 3 * (nx + ny)) #rn = 6.*n + (p*n+(p-1)*nx) + (p*n+(p-1)*ny) + (n+(p-1)*(nx+ny)) rn = 6. * n + (2 * p + 1) * n + 2 * (p - 1) * (nx + ny) ratio = rn / (tn * n) * 100 print sc.round_(ratio, 2), '%' print '\n3D' for n, nx, ny, nz in [(256, 16, 4, 4), (512, 16, 8, 4)]: print '(%d=%dx%dx%d)' % (n, nx, ny, nz) n2 = 6 * n + 3 * n + 2 * (nx * ny + ny * nz + nz * nx)
def __pyramid_ski__(frame,t = 7,k = 2): # create image pyramid from img, skimage implemetation py = pyramid_gaussian(frame, downscale = k) return [sp.round_(255.0*e).astype(sp.uint8) for e in py][:t]
def dnToTOA(inPath, outPath, sensor): """ Convertir les DNs en Radiance et/ou réflectance des images PlanetScope et RapidEye sensor = 0 if PlanetScope or 1 if RapidEye """ if sensor == 0: # PlanetScope # Search MS Image and Metadata XML File lstFile = [file for file in os.listdir(inPath)] # print (lstFile) for file in lstFile: if file.split('_')[-1] == "AnalyticMS.tif": inRaster = file elif file.split('_')[-1] == "metadata.xml": inMetadata = file # print (inRaster,inMetadata) # Parse XML and Get reflectanceCoefficient from Metadata File tree = ET.parse(os.path.join(inPath, inMetadata)) lstBand = [] lstRCoef = [] dicMetadata = {} for element in tree.iter(): if re.match("(.*)bandNumber", element.tag): lstBand.append(int(element.text)) elif re.match("(.*)reflectanceCoefficient", element.tag): lstRCoef.append(float(element.text)) # print (lstBand, lstRCoef) for i in range(len(lstBand)): dicMetadata.update({lstBand[i]: lstRCoef[i]}) # print (dicMetadata) # Open Raster File and Convert DN to TOA Reflectance g = gdal.Open(os.path.join(inPath, inRaster), gdal.GA_ReadOnly) if g is None: print('Can\'t open Analystic MS File. Please Check it.') sys.exit(1) # print (g) geoT = g.GetGeoTransform() Proj = g.GetProjection() x_size = g.RasterXSize # Raster xsize y_size = g.RasterYSize # Raster ysize bandCount = g.RasterCount nodata = g.GetRasterBand(1).GetNoDataValue() toaArray = sp.empty((y_size, x_size, bandCount), dtype=get_datatype(g)) for j in range(bandCount): dnArray = g.GetRasterBand(j + 1).ReadAsArray() toaArray[:, :, j] = sp.round_(dnArray * dicMetadata[j + 1] * 10000) # Write TOA Reflectance Image in GeoTiff outName = inRaster[:-4] + '_TOA.tif' # print (outName) outFolder = os.path.join( outPath, inRaster.split('_')[0][:4] + '_' + inRaster.split('_')[0][4:6] + '_' + inRaster.split('_')[0][6:8]) if not os.path.isdir(outFolder): os.makedirs(outFolder) outFile = os.path.join(outFolder, outName) driver = gdal.GetDriverByName('GTiff') dataType = gdal_array.NumericTypeCodeToGDALTypeCode(toaArray.dtype) # dataType=gdal.GetDataTypeName(toaArray.DataType) ds = driver.Create(outFile, x_size, y_size, bandCount, dataType, ['COMPRESS=LZW']) ds.SetGeoTransform(geoT) ds.SetProjection(Proj) for k in range(bandCount): ds.GetRasterBand(k + 1).WriteArray(toaArray[:, :, k]) if nodata != None: ds.GetRasterBand(k + 1).SetNoDataValue(nodata) g = None ds = None driver = None elif sensor == 1: # RapidEye # Search MS Image and Metadata XML File lstFile = [file for file in os.listdir(inPath)] # print (lstFile) for file in lstFile: if file.split('_')[-1] == "Analytic.tif": inRaster = file elif file.split('_')[-1] == "metadata.json": inMetadata = file # print (inRaster,inMetadata) # Open Raster File and Convert DN to TOA Reflectance # Exo-Atmospheric Irradiance (EAI) in W/m²/µm for each band successively 1-B 2-G 3-R 4-RE 5-NIR dicEAI = {1: 1997.8, 2: 1863.5, 3: 1560.4, 4: 1395., 5: 1124.4} # Solar Zenithal Angle (90°-sun elevation) Sun elevation is found in Metadata json file with open(os.path.join(inPath, inMetadata)) as json_file: content = json.load(json_file) SOLAR_ZENITH = 90 - float(content['properties']['sun_elevation']) ACQUISITION_DATE = content['properties']['acquired'][:10] # print (SOLAR_ZENITH) # print (ACQUISITION_DATE) # Compute Earth-Sun Distance at the day of acquisition in Astronomical Units. # At this time, the Earth-Sun Distance is done on this website : http://www.instesre.org/Aerosols/sol_calc.htm # lat = 14,64 & lon = -16,44 dicESUN = { "2017-07-27": 1.015107862579904, "2017-10-06": 0.99966670968068246, "2017-10-26": 0.994036745275356, "2017-11-09": 0.990452817341342, "2018-03-15": 0.9917799308371985 } ESUN = float(dicESUN[ACQUISITION_DATE]) # print (ESUN) # Create Gdal Dataset to compute TOA Reflectance g = gdal.Open(os.path.join(inPath, inRaster), gdal.GA_ReadOnly) if g is None: print('Can\'t open Analystic File. Please Check it.') sys.exit(1) # print (g) geoT = g.GetGeoTransform() Proj = g.GetProjection() x_size = g.RasterXSize # Raster xsize y_size = g.RasterYSize # Raster ysize bandCount = g.RasterCount nodata = g.GetRasterBand(1).GetNoDataValue() toaArray = sp.empty((y_size, x_size, bandCount), dtype=get_datatype(g)) for j in range(bandCount): dnArray = g.GetRasterBand(j + 1).ReadAsArray() toaArray[:, :, j] = sp.round_( dnArray * 0.01 * (pi * (ESUN**ESUN) / dicEAI[j + 1] * cos(SOLAR_ZENITH * pi / 180)) * 10000) # Save TOA Reflectance Image in GeoTiff outName = inRaster[:-4] + '_TOA.tif' # print (outName) outFolder = os.path.join( outPath, os.path.basename(inPath).split('_')[0][:4] + '_' + os.path.basename(inPath).split('_')[0][4:6] + '_' + os.path.basename(inPath).split('_')[0][6:8]) if not os.path.isdir(outFolder): os.makedirs(outFolder) outFile = os.path.join(outFolder, outName) driver = gdal.GetDriverByName('GTiff') dataType = gdal_array.NumericTypeCodeToGDALTypeCode(toaArray.dtype) # dataType=gdal.GetDataTypeName(toaArray.DataType) ds = driver.Create(outFile, x_size, y_size, bandCount, dataType, ['COMPRESS=LZW']) ds.SetGeoTransform(geoT) ds.SetProjection(Proj) for k in range(bandCount): ds.GetRasterBand(k + 1).WriteArray(toaArray[:, :, k]) if nodata != None: ds.GetRasterBand(k + 1).SetNoDataValue(nodata) g = None ds = None driver = None
def trainModel(self, do_pca=False, out_dir='./cache', rftop=40, class_labels=SP.array(['G1', 'S', 'G2M']), cv=10, npc=3, is_SVM=1, is_RFE=0, scale=False): if not os.path.exists(out_dir): os.makedirs(out_dir) CFG = {} CFG['is_RFE'] = is_RFE # use recursive feature selection (can be slow for large datasets) CFG['is_SVM'] = is_SVM # use SVM with univariate feature selection (faster than RFE) CFG['CV_inner'] = cv #inner CV for RFE_CV: either an int or 'LOOCV' CFG['out_dir'] = out_dir CFG['do_pca'] = do_pca CFG['lassotop'] = 20 self.cv = cv Y = self.Y labels = self.labels var_names = self.geneNames numClasses = self.numClasses predRF = SP.zeros((len(labels), numClasses)) predSVM = SP.zeros((len(labels), numClasses)) predSVMrbf = SP.zeros((len(labels), numClasses)) predGNB = SP.zeros((len(labels), numClasses)) predLR = SP.zeros((len(labels), numClasses)) predLRall = SP.zeros((len(labels), numClasses)) names_dict = {} if self.cv == 'LOOCV': loo = LeaveOneOut(len(labels)) CV_list = (list(iter(loo))) CV_list.append((SP.array(range(Y.shape[0])), SP.array(range(Y.shape[0])))) #all data... else: skf = StratifiedKFold(labels, n_folds=self.cv) CV_list = (list(iter(skf))) CV_list.append((SP.array(range(Y.shape[0])), SP.array(range(Y.shape[0])))) #all data... lambda_best = SP.zeros((1, len(CV_list))).ravel() print("Performing cross validation ...") for i in range(len(CV_list)): if i < len(CV_list) - 1: print("Fold " + str(i + 1) + " of " + str(len(CV_list) - 1)) else: print("Final model") # string label for this fold #get data of a CV run cv_tr = CV_list[i][0] cv_tst = CV_list[i][1] lab_tr = labels[cv_tr] Ytr = Y[cv_tr, :] Ytst = Y[cv_tst, :] lab_tst = labels[cv_tst] if (i == len(CV_list) - 1): foldlabel = 'full' if (self.Y_tst == None): Ytst = Y[cv_tst, :] lab_tst = labels[cv_tst] else: foldlabel = 'Test' Ytst = self.Y_tst lab_tst = self.labels_tst else: foldlabel = str(i) if do_pca >= 1: npc = npc #3 #do PCA to get features pcaCC = PCA(n_components=npc, whiten=False) pcaCC.fit(Ytr) pcaTst = pcaCC.transform(Ytst) pcaTr = pcaCC.transform(Ytr) #selection = SelectKBest(k=1) #combined_features = FeatureUnion([("pca", pcaCC), ("univ_select", selection)]) combined_features = FeatureUnion([("pca", pcaCC)]) gnb = GaussianNB() y_pred = gnb.fit(pcaTr, lab_tr).predict_proba(pcaTst) if i < len(CV_list) - 1: predGNB[cv_tst, :] = y_pred #[:,1] else: predGNB_ts = y_pred #[:,1] if do_pca == 2: Ytr = SP.concatenate((Ytr, pcaTr), 1) Ytst = SP.concatenate((Ytst, pcaTst), 1) pcnames = [] for pci in range(npc): pcnames.append('PC' + str(pci + 1)) var_names = SP.concatenate((var_names, SP.array(pcnames)), 1) print(" Computing random forest ...") if CFG['is_RFE'] == 1: #Recursive feature selection with SVM print(" Computing RFE with SVM ...") svc = SVC(kernel="linear", probability=False, class_weight='auto') #use linear SVM for selection rfecv = RFECV(estimator=svc, step=1, scoring='f1') param_grid = dict(estimator__C=[0.1, 1, 10, 100, 1000]) clf_rfe = GridSearchCV( rfecv, param_grid=param_grid, cv=3, scoring='f1') #GridSearch to find optimal parameters clf_rfe.fit(Ytr, lab_tr) svc = SVC(kernel="linear", probability=False, C=clf_rfe.best_estimator_.estimator.C, class_weight='auto') #use linear SVM for selection if CFG['CV_inner'] == '': rfecv = RFECV(estimator=svc, step=1, scoring='f1') elif CFG['CV_inner'] == 'LOOCV': rfecv = RFECV(estimator=svc, step=1, scoring='f1', cv=LeaveOneOut(len(lab_tr))) else: rfecv = RFECV(estimator=svc, step=1, scoring='f1', cv=StratifiedKFold(lab_tr, n_folds=CFG['CV_inner'])) clf_rfe.best_estimator_.fit(Ytr, lab_tr) predicted = clf_rfe.best_estimator_.predict(Ytst) if i < len(CV_list) - 1: predSVM[cv_tst, :] = predicted else: predSVM_ts[cv_tst] = predicted classifier = svm.SVC( kernel='rbf', gamma=0.05, class_weight='auto', probability=True) #rbf kernel for prediction param_grid = dict(C=[0.1, 1], gamma=[1e-1, 1e-2, 1e-3]) clf_rbf = GridSearchCV(classifier, param_grid=param_grid, cv=3, scoring='f1') clf_rbf.fit(Ytr[:, clf_rfe.best_estimator_.ranking_ == 1], lab_tr) clf_rbf.best_estimator_.fit( Ytr[:, clf_rfe.best_estimator_.ranking_ == 1], lab_tr) predicted = clf_rbf.best_estimator_.predict_proba( Ytst[:, clf_rfe.best_estimator_.ranking_ == 1]) if i < len(CV_list) - 1: predSVMrbf[cv_tst, :] = predicted fpr, tpr, thresholds = metrics.roc_curve( lab_tst, predicted[:, 1]) if (i == len(CV_list) - 1) | CFG["CV_plots"] > 0: PL.figure() PL.plot(fpr, tpr) PL.savefig(CFG['out_dir'] + '/RF_SVM_' + foldlabel + '.pdf') names_dict[foldlabel + '_SVM'] = self.geneNames[ clf_rfe.best_estimator_.ranking_ == 1] elif CFG[ 'is_SVM'] == 1: #univariate FS with rbf SVM; choose this if you hava a large data set (many features, eg RNAseq) print(" SVM feature selection ...") classifier = svm.SVC(kernel='rbf', gamma=0.05, class_weight='auto', probability=True) selection = SelectKBest(k=1) combined_features = FeatureUnion([("univ_select", selection)]) X_features = combined_features.fit(Ytr, lab_tr).transform(Ytr) scaler = preprocessing.StandardScaler().fit(Ytr) YtrS = scaler.transform(Ytr) YtstS = scaler.transform(Ytst) classifier.fit(X_features, lab_tr) pipeline = Pipeline([("features", combined_features), ("svm", classifier)]) if CFG['do_pca'] == 3: param_grid = dict( features__pca__n_components=SP.unique( SP.round_( SP.logspace(1.0, max(SP.log2(Ytr.shape[1]), SP.log2(10)), num=min(5, Ytr.shape[1]), base=2.0))), features__univ_select__k=SP.unique( SP.round_( SP.logspace(3.0, SP.log2(Ytr.shape[1]), num=min(10, Ytr.shape[1]), base=2.0))), svm__C=[0.1, 1, 10], svm__gamma=[1e-1, 1e-2, 1e-3]) else: C_range = 10.**SP.arange(0, 2) gamma_range = 10.**SP.arange(-5, 1) param_grid = dict(features__univ_select__k=SP.unique( SP.round_( SP.logspace(3.0, SP.log2(Ytr.shape[1]), num=min(10, Ytr.shape[1]), base=2.0))), svm__C=C_range, svm__gamma=gamma_range) clf = GridSearchCV(pipeline, param_grid=param_grid, cv=5, scoring='f1') clf.fit(YtrS, lab_tr) print("The best classifier is: ", clf.best_estimator_) select_best = clf.best_estimator_.get_params( )['features__univ_select'] #names_dict[foldlabel+'_SVM']=self.geneNames[SP.argsort(-1.0*select_best.scores_)[0:(select_best.k-1)]] expected = lab_tst predicted = clf.best_estimator_.predict_proba(YtstS) if i < len(CV_list) - 1: predSVM[cv_tst, :] = predicted else: predSVM_ts = predicted #print(clf.best_estimator_) classifier = svm.SVC( kernel='rbf', gamma=0.05, class_weight='auto', probability=True) #rbf kernel for prediction param_grid = dict(C=[1, 10], gamma=[1e-1, 1e-2, 1e-3]) clf_rbf = GridSearchCV(classifier, param_grid=param_grid, cv=5, scoring='f1') clf_rbf.fit(Ytr, lab_tr) clf_rbf.best_estimator_.fit(Ytr, lab_tr) predicted = clf_rbf.best_estimator_.predict_proba(Ytst) if i < len(CV_list) - 1: predSVMrbf[cv_tst, :] = predicted else: predSVMrbf_ts = predicted #do lasso with regularisation path cs = l1_min_c(Ytr, lab_tr, loss='log') * SP.logspace(0, 3) print(" Computing regularization path ...") lasso = linear_model.LogisticRegression(C=cs[0] * 10.0, penalty='l1', tol=1e-6) param_grid = dict(C=cs) clf_lr = GridSearchCV(lasso, param_grid=param_grid, cv=5, scoring='f1') clf_lr.fit(Ytr, lab_tr) clf_lr.best_estimator_.fit(Ytr, lab_tr) lambda_best[i] = clf_lr.best_params_.get('C') predicted = clf_lr.best_estimator_.predict_proba(Ytst) clf = linear_model.LogisticRegression(C=cs[0] * 10.0, penalty='l1', tol=1e-6) coefs_ = [] for c in cs: clf.set_params(C=c) clf.fit(Ytr, lab_tr) coefs_.append(clf.coef_.ravel().copy()) if i < len(CV_list) - 1: predLR[cv_tst, :] = predicted else: predLR_ts = predicted coefs_ = SP.array(coefs_) # get ordering by importance (how many times they appear) order = (coefs_ != 0).sum(axis=0).argsort() order = order[::-1] # descending # store this order featrank_lasso = order showtop = min(Ytr.shape[1], CFG['lassotop']) clfAll = linear_model.LogisticRegression(C=1e5, penalty='l2', tol=1e-6) clfAll.fit(Ytr, lab_tr) predicted = clfAll.predict_proba(Ytst) if i < len(CV_list) - 1: predLRall[cv_tst, :] = predicted else: predLRall_ts = predicted forest = ExtraTreesClassifier(n_estimators=500, random_state=0, criterion="entropy", bootstrap=False) #forest = RandomForestClassifier(n_estimators=500, # random_state=0, criterion="entropy") forest.fit(Ytr, lab_tr) pred = forest.predict_proba(Ytst) #pdb.set_trace() if i < len(CV_list) - 1: predRF[cv_tst, :] = pred #[:,1] else: predRF_ts = pred #[:,1] importances = forest.feature_importances_ std = SP.std( [tree.feature_importances_ for tree in forest.estimators_], axis=0) topfeat = min(Ytr.shape[1], rftop) indices = SP.argsort(importances)[::-1][0:topfeat] # store full feature ranking featrank_rf = SP.argsort(importances)[::-1] # Plot the feature importances of the forest if (i == len(CV_list) - 1): PL.figure() #PL.title("Feature importances, Fold "+foldddPPlabel+', AUC='+str(SP.round_(metrics.auc(fpr, tpr),3))) PL.title("Feature importances") #PL.bar(range(topfeat), importances[indices],color="r", yerr=std[indices], align="center") PL.bar(range(topfeat), importances[indices], color="r", align="center") PL.xticks(range(topfeat), indices, rotation=70) PL.gca().set_xticklabels(var_names[indices]) PL.setp(PL.gca().get_xticklabels(), fontsize=8) PL.xlim([-1, topfeat]) PL.savefig(out_dir + '/RF_featureimportance_' + foldlabel + '.pdf') f2 = open(os.path.join(out_dir, 'classification_reportCV.txt'), 'w') predRFv = SP.argmax(predRF_ts, axis=1) + 1 predRF_trv = SP.argmax(predRF, axis=1) + 1 self.scores = predRF self.scores_tst = predRF_ts self.ranking = var_names[indices] predLRv = SP.argmax(predLR_ts, axis=1) + 1 predLR_trv = SP.argmax(predLR, axis=1) + 1 self.scoresLR = predLR self.scoresLR_tst = predLR_ts predLRallv = SP.argmax(predLRall_ts, axis=1) + 1 predLRall_trv = SP.argmax(predLRall, axis=1) + 1 self.scoresLRall = predLRall self.scoresLRall_tst = predLRall_ts if CFG['is_SVM'] == 1: predSVMv = SP.argmax(predSVM_ts, axis=1) + 1 predSVM_trv = SP.argmax(predSVM, axis=1) + 1 self.scoresSVM = predSVM self.scoresSVM_tst = predSVM_ts predSVMrbfv = SP.argmax(predSVMrbf_ts, axis=1) + 1 predSVMrbf_trv = SP.argmax(predSVMrbf, axis=1) + 1 self.scoresSVMrbf = predSVMrbf self.scoresSVMrbf_tst = predSVMrbf_ts predGNBv = SP.argmax(predGNB_ts, axis=1) + 1 predGNB_trv = SP.argmax(predGNB, axis=1) + 1 self.scoresGNB = predGNB self.scoresGNB_tst = predGNB_ts print("Classification report for classifier %s:\n%s\n" % ('Gaussian Naive Bayes', metrics.classification_report(self.labels, predGNB_trv))) print("Classification report for classifier %s:\n%s\n" % ('Random Forest', metrics.classification_report(self.labels, predRF_trv))) print("Classification report for classifier %s:\n%s\n" % ('LR', metrics.classification_report(self.labels, predLR_trv))) print("Classification report for classifier %s:\n%s\n" % ('LRall', metrics.classification_report(self.labels, predLRall_trv))) if CFG['is_RFE'] == 1: print( "Classification report for classifier %s:\n%s\n" % ('SVM ', metrics.classification_report(labels, predSVM > 0.5)), file=f2) elif CFG['is_SVM'] == 1: print("Classification report for classifier %s:\n%s\n" % ('SVM', metrics.classification_report(self.labels, predSVM_trv))) print("Classification report for classifier %s:\n%s\n" % ('SVMrbf', metrics.classification_report(self.labels, predSVMrbf_trv))) f2.close()
prec = {'S0':[],'S1':[]} rec = {'S0':[],'S1':[]} scores = [] min_score = 1 for train, test in cv: x_train, y_train = x.iloc[train,:], y.iloc[train] x_test, y_test = x.iloc[test,:], y.iloc[test] ## x_train, y_train = x,y ## x_test, y_test = xt,yt clf.fit(x_train, y_train) y_p=clf.predict(x_test) females=sp.round_(x_train.SexN,2)==-1.36 xf = x_train.loc[females,:].drop(['SexN','SexClass','SexParch','Mr','Master','Rev'],1) yf = y_train.loc[females] clf.fit(xf, yf) yf_p =clf.predict(x_test.drop(['SexN','SexClass','SexParch','Mr','Master','Rev'],1)) males=sp.round_(x_train.SexN,2)==0.74 xm = x_train.loc[males,:].drop(['SexN','SexClass','SexParch','Miss','Mrs'],1) ym = y_train.loc[males] clf.fit(xm, ym) ym_p =clf.predict(x_test.drop(['SexN','SexClass','SexParch','Miss','Mrs'],1)) for i in range(0,len(x_test)): if (x_test.iloc[i,:].SexN == 1) & (y_p[i] == 0): y_p[i]=yf_p[i]
@author: james """ import matplotlib.pyplot as plt import scipy import scipy.stats df = pd.read_excel( r"C:\Users\james\Documents\School\Machine Learning & Data mining\Project1\Data\hprice2.xls", header=None) cols = range(0, 11) raw_data = df.get_values() X = raw_data[:, cols] size = 30000 x = scipy.arange(size) y = scipy.int_(scipy.round_(scipy.stats.vonmises.rvs(5, size=size) * 47)) h = plt.hist(y, bins=range(48)) dist_names = ['gamma', 'beta', 'rayleigh', 'norm', 'pareto'] for dist_name in dist_names: dist = getattr(scipy.stats, dist_name) param = dist.fit(y) pdf_fitted = dist.pdf(x, *param[:-2], loc=param[-2], scale=param[-1]) * size plt.plot(pdf_fitted, label=dist_name) plt.xlim(0, 47) plt.legend(loc='upper right') plt.show()
# from https://stackoverflow.com/questions/6620471/fitting-empirical-distribution-to-theoretical-ones-with-scipy-python # Saullo's answer import matplotlib.pyplot as plt import scipy import scipy.stats size = 20000 x = scipy.arange(size) # creating the dummy sample (using beta distribution) y = scipy.int_(scipy.round_(scipy.stats.beta.rvs(6,2,size=size)*47)) # creating the histogram h = plt.hist(y, bins=range(48), density=True) dist_names = ['alpha', 'beta', 'arcsine', 'weibull_min', 'weibull_max', 'rayleigh'] for dist_name in dist_names: dist = getattr(scipy.stats, dist_name) param = dist.fit(y) pdf_fitted = dist.pdf(x, *param[:-2], loc=param[-2], scale=param[-1]) plt.plot(pdf_fitted, label=dist_name) plt.xlim(0,47) plt.legend(loc='upper left') plt.show() #NB : from scipy.stats._continuous_distns import _distn_names #all dist names #fit() method mentioned by @Saullo Castro provides maximum likelihood estimates (MLE). The best distribution for your data is the one give you the highest can be determined by several different ways: such as #1, the one that gives you the highest log likelihood. #2, the one that gives you the smallest AIC, BIC or BICc values (see wiki: http://en.wikipedia.org/wiki/Akaike_information_criterion, basically can be viewed as log likelihood adjusted for number of parameters, as distribution with more parameters are expected to fit better) #3, the one that maximize the Bayesian posterior probability. (see wiki: http://en.wikipedia.org/wiki/Posterior_probability)
def gprint(G, mtype="obs", bend=5, curve=5, R=1, layout=None, scale=5): """ Prints out an automatically layout compressed dbn repesentation of the graph in TikZ/Latex format """ output = StringIO.StringIO() BE = set() n = len(G) if not layout: g = dict2graph(ecj.cloneBfree(G)) layout = g.layout_fruchterman_reingold(maxiter=50000, coolexp=1.1) #layout = g.layout_graphopt(niter=50000, node_charge=0.08) layout.center([0, 0]) layout.scale(float(1 / scipy.absolute(layout.coords).max())) layout.scale(R) cc = scipy.round_(array(layout.coords), decimals=4) else: g = dict2graph(ecj.cloneBfree(G)) cc = array(layout.coords) paintSCC(g, colors) for i in range(0, n): node = g.vs[i]['label'] rc = g.vs[i]["color"] print >>output, "{ \\definecolor{mycolor}{RGB}{"\ +str(rc[0])+","+str(rc[1])+","+str(rc[2])+"}" mcolor = "fill = {rgb: red,"+str(rc[0])+"; green,"+str(rc[1])+\ "; blue,"+str(rc[2])+"}" print >>output, "\\node["+mtype+", fill=mycolor] ("+node+") at ("+\ str(cc[i][0])+","+str(cc[i][1])+") {"+node+"};}" for i in range(0, n): v = g.vs[i]['label'] ll = [v + '/' + u for u in G[v]] for l in ll: a, b = l.split('/') if G[a][b].intersection([(edge_type['bidirected'], 0)]): if not (BE.intersection([(a, b)]) or BE.intersection([(b, a)])): print >>output,' \\draw[pilip, on layer=back] ('+\ a+') -- ('+b+');' if G[a][b].intersection([(edge_type['directed'], 1)]): if a == b: dff = cc[g.vs['label'].index(a)] - scipy.mean(cc, 0) ang = scipy.arctan2(dff[1], dff[0]) ang_a = scipy.rad2deg(ang) print >>output,"\\path[overlay,draw,pil] ("+a+")" +\ " .. controls +("+ "%.5f" % (bend+ang_a) +\ ":"+ fstr % (2*curve)+"mm) and +("+\ "%.5f" % (ang_a-bend)+\ ":"+"%.5f" % (2*curve)+"mm) .. ("+b+");" else: dff = cc[g.vs['label'].index(b)] \ - cc[g.vs['label'].index(a)] ang = scipy.arctan2(dff[1], dff[0]) ang_a = scipy.rad2deg(ang) ang_b = ang_a + 180 print >>output,"\\path[overlay,draw,pil] ("+a+")" +\ " .. controls +("+\ "%.5f" % (bend+ang_a) +\ ":"+fstr % (curve)+"mm) and +("+\ fstr % (ang_b-bend)+\ ":"+fstr % (curve)+"mm) .. ("+b+");" return output
plt.figure(2) ax = plt.axes(projection='3d') ax.plot3D(x_o/1000,y_o/1000,z_o/1000) plt.savefig('3d.png') ''' DERIVA ODEINT ''' deriva = sp.zeros(len(tiempo)) for i in range(len(tiempo)): deriva[i] = sp.sqrt(sp.dot((z_odeint[i,:3] - [x[i],y[i],z[i]]), (z_odeint[i,:3] - [x[i],y[i],z[i]]))) z_f = sp.sqrt(sp.dot([x[i],y[i],z[i]],[x[i],y[i],z[i]])) error = sp.round_(deriva[-1]/z_f,2) print (f'Error = {error*100} %') dist_max = sp.round_(sp.amax(deriva)/1000,1) plt.figure(3) plt.title(f'Distancia entre eulerint y odeint, $δ_m$ = {dist_max} (km)') plt.ylabel('Deriva, δ [KM]') plt.xlabel('Tiempo, $t$ [h]') plt.plot(t/3600,deriva/1000) plt.tight_layout() plt.savefig('deriva_odeint.png')
def plotPerformance(self, perfType='ROC', plot_test=True, out_dir='./cache', class_labels=['G1 phase', 'S phase', 'G2M phase'], method='RF'): plparams = { 'backend': 'pdf', 'axes.labelsize': 14, 'text.fontsize': 14, 'legend.fontsize': 13, 'xtick.labelsize': 14, 'ytick.labelsize': 14, 'text.usetex': False } PL.rcParams.update(plparams) assert (perfType in ['ROC', 'PR']) if plot_test == True: if method == 'RF': labs = self.labels_tst scores = self.scores_tst elif method == 'LR': labs = self.labels_tst scores = self.scoresLR_tst elif method == 'LRall': labs = self.labels_tst scores = self.scoresLRall_tst elif method == 'GNB': labs = self.labels_tst scores = self.scoresGNB_tst elif method == 'SVM': labs = self.labels_tst scores = self.scoresSVM_tst elif method == 'SVMrbf': labs = self.labels_tst scores = self.scoresSVMrbf_tst else: if method == 'RF': labs = self.labels scores = self.scores elif method == 'LR': labs = self.labels scores = self.scoresLR elif method == 'LRall': labs = self.labels scores = self.scoresLRall elif method == 'GNB': labs = self.labels scores = self.scoresGNB elif method == 'SVM': labs = self.labels scores = self.scoresSVM elif method == 'SVMrbf': labs = self.labels scores = self.scoresSVMrbf PL.figure() #col = ['r', 'b', 'g'] col = ['#1b9e77', '#d95f02', '#7570b3'] aucList = SP.zeros((scores.shape[1], )) for ind in range(scores.shape[1]): labels_i = labs.copy() scores_i = scores[:, ind] labels_i[labs == ind + 1] = 1 labels_i[labs != ind + 1] = 0 if perfType == 'ROC': fpr, tpr, thresholds = metrics.roc_curve(labels_i, scores_i) aucList[ind] = metrics.auc(fpr, tpr) elif perfType == 'PR': fpr, tpr, thresholds = metrics.precision_recall_curve( labels_i, scores_i) PL.plot(fpr, tpr, '-', c=col[ind]) if perfType == 'ROC': PL.title("ROC curve ccClassify") PL.xlabel('FPR') PL.ylabel('TPR') leg_str = list() for i in range(len(class_labels)): leg_str.append(class_labels[i] + ', AUC = ' + str(SP.round_(aucList[i], 3))) PL.legend(leg_str, loc='lower-right') ax = plt.gca() ax.spines["right"].set_visible(False) ax.spines["top"].set_visible(False) ax.get_xaxis().tick_bottom() ax.get_yaxis().tick_left() PL.savefig(out_dir + '/ROC_test' + str(plot_test) + '_' + method + '.pdf', bbox_inches='tight') else: PL.title("PR curve ccClassify") PL.xlabel('Precision') PL.ylabel('Recall') leg_str = list() for i in range(len(class_labels)): leg_str.append(class_labels[i] ) #+', AUC = '+str(SP.round_(aucList[i],3))) PL.legend(leg_str, loc='lower-right') ax = plt.gca() ax.spines["right"].set_visible(False) ax.spines["top"].set_visible(False) ax.get_xaxis().tick_bottom() ax.get_yaxis().tick_left() PL.savefig(out_dir + '/ROC_test' + str(plot_test) + '_' + method + '.pdf', bbox_inches='tight')
def prices(request): try: required_options = set([o for o in request.POST.keys() if request.POST[o] == u'true']) published_options = sorted( #PublishOptionContract.objects.filter(optiondefinition_id=option.id), PublishOptionContract.objects.all(), key = lambda x : x.strike) published_option_definitions = set([]) for o in published_options: published_option_definitions.add(o.optiondefinition) futures = sorted( Future.objects.all() , key = lambda x : x.name) futures = [el for el in futures if el.expiry_date > datetime.datetime.today()] option_definitions = OptionDefinition.objects.all() #if len(required_options) == 0: # required_options = set(option_definitions) option_definitions = [el for el in option_definitions if el.expiry_date > datetime.datetime.today() and el.name in required_options] #option_definition_dict = dict([(o, o.name) for o in option_definitions]) futuredict = collections.OrderedDict() for future in futures: futuredict[future] = collections.OrderedDict() for option_def in option_definitions: if option_def.future == future: #futuredict[future][option_definition_dict[option_def]] = collections.OrderedDict() futuredict[future][option_def] = collections.OrderedDict() publishedcontracts = sorted( [i for i in published_options if i.optiondefinition == option_def], key = lambda x : x.strike) if len(publishedcontracts) > 0: futuredict[future][option_def]['published'] = True #futuredict[future][option_definition_dict[option_def]]['published_time'] = publishedcontracts[0].publish_time futuredict[future][option_def]['published_time'] = publishedcontracts[0].publish_time table_data = [] atm_strike = hf.ATM_strike([c.strike for c in publishedcontracts], publishedcontracts[0].future_value) time2expiry = hf.diff_dates_year_fraction(option_def.expiry_date, publishedcontracts[0].publish_time) random_column = [] for pos, o in enumerate(publishedcontracts): if o.strike == atm_strike: random_column.append(scipy.round_(hf.black_pricer(time2expiry, o.future_value, o.strike, o.vol, call = True) + hf.black_pricer(time2expiry, o.future_value, o.strike, o.vol, call = False), decimals = 5)) else: random_column.append('') published_strikes = [] published_vols = [] for pos, c in enumerate(publishedcontracts): table_data.append( ( scipy.round_(c.strike, decimals=5), scipy.round_(c.call_value, decimals=5), scipy.round_(c.put_value, decimals=5), random_column[pos], scipy.round_(c.call_delta, decimals=2), scipy.round_(c.put_delta, decimals=2), scipy.round_(c.gamma, decimals=3), scipy.round_(c.theta, decimals=2), scipy.round_(c.vega, decimals=2), scipy.round_(c.vol, decimals=5), scipy.round_(c.change, decimals=5), ) ) published_strikes.append(c.strike) published_vols.append(c.vol) #futuredict[future][option_definition_dict[option_def]]['table_data'] = table_data futuredict[future][option_def]['table_data'] = table_data optioncontracts = sorted( OptionContract.objects.filter(optiondefinition_id=option_def.id), key = lambda x : x.strike) strikes = [o.strike for o in optioncontracts] all_strikes = set(strikes) all_strikes.update(set(published_strikes)) all_strikes = sorted(list(all_strikes)) published_vols = hf.remap_values(published_vols, published_strikes, all_strikes) futuredict[future][option_def]['published_vols'] = published_vols bids = hf.remap_values([o.bid if o.bid > 0 else None for o in optioncontracts], strikes, all_strikes) asks = hf.remap_values([o.ask if o.ask > 0 else None for o in optioncontracts], strikes, all_strikes) last_trade_value = hf.remap_values([o.last_trade_value if o.last_trade_value > 0 else None for o in optioncontracts], strikes, all_strikes) values = hf.remap_values([o.value if o.value > 0 else None for o in optioncontracts], strikes, all_strikes) future = option_def.future callbool = [True if o.easy_screen_mnemonic[-3] == 'c' else False for o in optioncontracts] today = datetime.date.today() time2expiry = hf.diff_dates_year_fraction(option_def.expiry_date, today) bid_vols = [hf.black_pricer_vol(time2expiry, future.bid, K, Val, call) for K, Val, call in zip(strikes, bids, callbool)] ask_vols = [hf.black_pricer_vol(time2expiry, future.bid, K, Val, call) for K, Val, call in zip(strikes, asks, callbool)] last_trade_vols = [hf.black_pricer_vol(time2expiry, future.last_trade_value, K, Val, call) for K, Val, call in zip(strikes, last_trade_value, callbool)] value_vols = [hf.black_pricer_vol(time2expiry, future.bid, K, Val, call) for K, Val, call in zip(strikes, values, callbool)] value_vols = hf.spline_interpolate(value_vols, strikes) futuredict[future][option_def]['strikes'] = json.dumps(all_strikes) futuredict[future][option_def]['bid_vols'] = json.dumps(bid_vols) futuredict[future][option_def]['ask_vols'] = json.dumps(ask_vols) futuredict[future][option_def]['last_trade_vols'] = json.dumps(last_trade_vols) futuredict[future][option_def]['value_vols'] = json.dumps(value_vols) else: futuredict[future][option_def]['published'] = False if len(required_options) > 0: containsdata = True else: containsdata = False template = loader.get_template('prices.html') context = RequestContext(request, { 'futuredict': futuredict, 'containsdata' : containsdata }) return HttpResponse(template.render(context)) except Exception as e: #print e raise Http404 return render(request, 'prices.html')
salmapFile = matpyfiles['salmapFile'][0][0][0] iou = params['params'][0]['windows'][0]['iou'][0][0][0][0] scales = params['params'][0]['windows'][0]['scale'][0][0][0] aspRatio = params['params'][0]['windows'][0]['aspRatio'][0][0][0] # Initializing and loading files salmap = sio.loadmat(salmapFile) salmap = salmap['salmap'] windows = [] rows, cols = salmap.shape[0], salmap.shape[1] imgArea = rows * cols stepFactor = ((1 - iou) / (1 + iou)) # Generate Windows for scale in scales: winArea = scale * imgArea for ar in aspRatio: width = int(sp.round_(sqrt(winArea * ar))) height = int(sp.round_(sqrt(float(winArea) / ar))) stepH = int(sp.round_(width * stepFactor)) stepV = int(sp.round_(height * stepFactor)) for rmin in xrange(0, rows - height + 1, stepV): for cmin in xrange(0, cols - width + 1, stepH): rmax = min(rows - 1, rmin + height) cmax = min(cols - 1, cmin + width) windows.append([cmin, rmin, cmax, rmax]) windows = sp.array(windows) + 1 sio.savemat(windowsFile, mdict={'windows': windows})
wgm_phi = sp.cos(m * phi) + sp.sin(m * phi) * sp.sqrt(-1) heavymap = sp.heaviside((r / a) - 1, 1) if (m == 7): wgm = sp.real(wgm_phi * int_wgm_rho * (1 - heavymap) + B * wgm_phi * ext_wgm_rho * heavymap) else: wgm = wgm + sp.real(wgm_phi * int_wgm_rho * (1 - heavymap) + B * wgm_phi * ext_wgm_rho * heavymap) m += 1 #%%draw on circle heavyp = sp.heaviside(r - 0.995 * a, 1) heavyn = sp.heaviside(1.005 * a - r, 1) xlab = sp.round_(x, 2) ylab = sp.round_(y, 2) circle = pd.DataFrame(heavyp * heavyn, index=ylab, columns=xlab) #%% make heatmap of function g = sns.heatmap(wgm, cmap="RdBu_r", xticklabels=True, yticklabels=True, square=True) circle_palette = [(0xFF / 0xFF, 0xFF / 0xFF, 0xFF / 0xFF, 0.001), (0xD1 / 0xFF, 0xEC / 0xFF, 0x9C / 0xFF, 1)] cmap = mpl.colors.ListedColormap(circle_palette) c = sns.heatmap(circle, cmap=cmap, xticklabels=100,
def gprint(G, mtype="obs", bend=5, curve=5, R=1, layout=None, scale=5): """ Prints out an automatically layout compressed dbn repesentation of the graph in TikZ/Latex format """ output = StringIO.StringIO() BE = set() n = len(G) if not layout: g = dict2graph(ecj.cloneBfree(G)) layout = g.layout_fruchterman_reingold(maxiter=50000, coolexp=1.1) # layout = g.layout_graphopt(niter=50000, node_charge=0.08) layout.center([0, 0]) layout.scale(float(1 / scipy.absolute(layout.coords).max())) layout.scale(R) cc = scipy.round_(array(layout.coords), decimals=4) else: g = dict2graph(ecj.cloneBfree(G)) cc = array(layout.coords) paintSCC(g, colors) for i in range(0, n): node = g.vs[i]['label'] rc = g.vs[i]["color"] print >>output, "{ \\definecolor{mycolor}{RGB}{"\ + str(rc[0]) + "," + str(rc[1]) + "," + str(rc[2]) + "}" mcolor = "fill = {rgb: red," + str(rc[0]) + "; green," + str(rc[1]) +\ "; blue," + str(rc[2]) + "}" print >>output, "\\node[" + mtype + ", fill=mycolor] (" + node + ") at (" +\ str(cc[i][0]) + "," + str(cc[i][1]) + ") {" + node + "};}" for i in range(0, n): v = g.vs[i]['label'] ll = [v + '/' + u for u in G[v]] for l in ll: a, b = l.split('/') if G[a][b].intersection([(edge_type['bidirected'], 0)]): if not(BE.intersection([(a, b)]) or BE.intersection([(b, a)])): print >>output, ' \\draw[pilip, on layer=back] (' +\ a + ') -- (' + b + ');' if G[a][b].intersection([(edge_type['directed'], 1)]): if a == b: dff = cc[g.vs['label'].index(a)] - scipy.mean(cc, 0) ang = scipy.arctan2(dff[1], dff[0]) ang_a = scipy.rad2deg(ang) print >>output, "\\path[overlay,draw,pil] (" + a + ")" +\ " .. controls +(" + "%.5f" % (bend + ang_a) +\ ":" + fstr % (2 * curve) + "mm) and +(" +\ "%.5f" % (ang_a - bend) +\ ":" + "%.5f" % (2 * curve) + "mm) .. (" + b + ");" else: dff = cc[g.vs['label'].index(b)] \ - cc[g.vs['label'].index(a)] ang = scipy.arctan2(dff[1], dff[0]) ang_a = scipy.rad2deg(ang) ang_b = ang_a + 180 print >>output, "\\path[overlay,draw,pil] (" + a + ")" +\ " .. controls +(" +\ "%.5f" % (bend + ang_a) +\ ":" + fstr % (curve) + "mm) and +(" +\ fstr % (ang_b - bend) +\ ":" + fstr % (curve) + "mm) .. (" + b + ");" return output
print '\nwithout using cache' print tn, '(*n)' print '\n2nd\t4th\t6th\t8th\t(spatial order)' print '1D' for n,nx in [(256,256), (512,512)]: print '(%d=%d)' % (n,nx) n2 = 6*n + 3*n + (2*n+1) + (2*n+1) n4 = 6*n + 7*n + (4*n+3) + (4*n+3) n6 = 6*n + 11*n + (6*n+5) + (6*n+5) n8 = 6*n + 15*n + (8*n+7) + (8*n+7) #rn = 6.*n + (2*p-1)*n + (p*n+p-1) + (p*n+p-1) rn = 6.*n + (4*p-1)*n + 2*(p-1) #print rn ratio = rn/(tn*n)*100 print sc.round_(ratio,2), '%' print '\n2D' for n,nx,ny in [(256,16,16), (512,32,16)]: print '(%d=%dx%d)' % (n,nx,ny) n2 = 6*n + (2*n+nx) + (2*n+ny) + (n+(nx+ny)) n4 = 6*n + (4*n+3*nx) + (4*n+3*ny) + (n+3*(nx+ny)) #rn = 6.*n + (p*n+(p-1)*nx) + (p*n+(p-1)*ny) + (n+(p-1)*(nx+ny)) rn = 6.*n + (2*p+1)*n + 2*(p-1)*(nx+ny) ratio = rn/(tn*n)*100 print sc.round_(ratio,2), '%' print '\n3D' for n,nx,ny,nz in [(256,16,4,4), (512,16,8,4)]: print '(%d=%dx%dx%d)' % (n,nx,ny,nz) n2 = 6*n + 3*n + 2*(nx*ny+ny*nz+nz*nx)
def __pyramid_ski__(frame,steps = 7,scale = 2): # create image pyramid from img, skimage implemetation py = pyramid_gaussian(frame, downscale = scale) return [sp.round_(255.0*e).astype(sp.uint8) for e in py][:steps]
def getCorrection(x,y,x_sv, y_sv): '''looks up correction in calculated vector fields''' xi = np.maximum(np.minimum(sp.round_(x/100).astype('i'), x_sv.shape[0]),0) yi = np.maximum(np.minimum(sp.round_(y/100).astype('i'), x_sv.shape[1]),0) return (x_sv[xi, yi],y_sv[xi, yi])