def compute_color_prior(size=64, do_plot=False): # Load the gamut points location q_ab = np.load(os.path.join(data_dir, "pts_in_hull.npy")) if do_plot: plt.figure(figsize=(15, 15)) gs = gridspec.GridSpec(1, 1) ax = plt.subplot(gs[0]) for i in range(q_ab.shape[0]): ax.scatter(q_ab[:, 0], q_ab[:, 1]) ax.annotate(str(i), (q_ab[i, 0], q_ab[i, 1]), fontsize=6) ax.set_xlim([-110, 110]) ax.set_ylim([-110, 110]) with h5py.File(os.path.join(data_dir, "CelebA_%s_data.h5" % size), "a") as hf: # Compute the color prior over a subset of the training set # Otherwise it is quite long X_ab = hf["training_lab_data"][:100000][:, 1:, :, :] npts, c, h, w = X_ab.shape X_a = np.ravel(X_ab[:, 0, :, :]) X_b = np.ravel(X_ab[:, 1, :, :]) X_ab = np.vstack((X_a, X_b)).T if do_plot: plt.hist2d(X_ab[:, 0], X_ab[:, 1], bins=100, norm=LogNorm()) plt.xlim([-110, 110]) plt.ylim([-110, 110]) plt.colorbar() plt.show() plt.clf() plt.close() # Create nearest neighbord instance with index = q_ab NN = 1 nearest = nn.NearestNeighbors(n_neighbors=NN, algorithm='ball_tree').fit(q_ab) # Find index of nearest neighbor for X_ab dists, ind = nearest.kneighbors(X_ab) # We now count the number of occurrences of each color ind = np.ravel(ind) counts = np.bincount(ind) idxs = np.nonzero(counts)[0] prior_prob = np.zeros((q_ab.shape[0])) for i in range(q_ab.shape[0]): prior_prob[idxs] = counts[idxs] # We turn this into a color probability prior_prob = prior_prob / (1.0 * np.sum(prior_prob)) # Save np.save(os.path.join(data_dir, "CelebA_%s_prior_prob.npy" % size), prior_prob) if do_plot: plt.hist(prior_prob, bins=100) plt.yscale("log") plt.show()
def compute_color_prior(size=64, do_plot=False): # Load the gamut points location q_ab = np.load(os.path.join(data_dir, "pts_in_hull.npy")) if do_plot: plt.figure(figsize=(15, 15)) gs = gridspec.GridSpec(1, 1) ax = plt.subplot(gs[0]) for i in range(q_ab.shape[0]): ax.scatter(q_ab[:, 0], q_ab[:, 1]) ax.annotate(str(i), (q_ab[i, 0], q_ab[i, 1]), fontsize=6) ax.set_xlim([-110,110]) ax.set_ylim([-110,110]) with h5py.File(os.path.join(data_dir, "CelebA_%s_data.h5" % size), "a") as hf: # Compute the color prior over a subset of the training set # Otherwise it is quite long X_ab = hf["training_lab_data"][:100000][:, 1:, :, :] npts, c, h, w = X_ab.shape X_a = np.ravel(X_ab[:, 0, :, :]) X_b = np.ravel(X_ab[:, 1, :, :]) X_ab = np.vstack((X_a, X_b)).T if do_plot: plt.hist2d(X_ab[:, 0], X_ab[:, 1], bins=100, norm=LogNorm()) plt.xlim([-110, 110]) plt.ylim([-110, 110]) plt.colorbar() plt.show() plt.clf() plt.close() # Create nearest neighbord instance with index = q_ab NN = 1 nearest = nn.NearestNeighbors(n_neighbors=NN, algorithm='ball_tree').fit(q_ab) # Find index of nearest neighbor for X_ab dists, ind = nearest.kneighbors(X_ab) # We now count the number of occurrences of each color ind = np.ravel(ind) counts = np.bincount(ind) idxs = np.nonzero(counts)[0] prior_prob = np.zeros((q_ab.shape[0])) for i in range(q_ab.shape[0]): prior_prob[idxs] = counts[idxs] # We turn this into a color probability prior_prob = prior_prob / (1.0 * np.sum(prior_prob)) # Save np.save(os.path.join(data_dir, "CelebA_%s_prior_prob.npy" % size), prior_prob) if do_plot: plt.hist(prior_prob, bins=100) plt.yscale("log") plt.show()
def compute_color_prior(X_ab, show_grid=False): """ 计算先验色 :param X_ab: :param show_grid: :return: """ q_ab = np.load("../data/params/pts_in_hull.npy") if show_grid: plt.figure(figsize=(15, 15)) gs = gridspec.GridSpec(1, 1) ax = plt.subplot(gs[0]) for i in range(q_ab.shape[0]): ax.scatter(q_ab[:, 0], q_ab[:, 1]) ax.annotate(str(i), (q_ab[i, 0], q_ab[i, 1]), fontsize=6) ax.set_xlim([-110, 110]) ax.set_ylim([-110, 110]) X_a = np.ravel(X_ab[:, :, :, 0]) X_b = np.ravel(X_ab[:, :, :, 1]) X_ab = np.vstack((X_a, X_b)).T if show_grid: plt.hist2d(X_ab[:, 0], X_ab[:, 1], bins=100, normed=True, norm=LogNorm()) plt.xlim([-110, 110]) plt.ylim([-110, 110]) plt.colorbar() plt.show() plt.clf() plt.close() nearest = nn.NearestNeighbors(n_neighbors=1, algorithm='ball_tree').fit(q_ab) distances, index = nearest.kneighbors(X_ab) index = np.ravel(index) counts = np.bincount(index) idxs = np.nonzero(counts)[0] prior_prob = np.zeros((q_ab.shape[0])) for i in range(q_ab.shape[0]): prior_prob[idxs] = counts[idxs] # 返回先验概率 prior_prob = prior_prob / (1.0 * np.sum(prior_prob)) # Save np.save("../data/params/prior_prob.npy", prior_prob) if show_grid: plt.hist(prior_prob, bins=100) plt.yscale("log") plt.show()
def eur_vs_imputed_aaf(m): # Color proportional to #variants P.figure(3) P.clf() in_both = (m[:, 0] > 0) & (m[:, 2] > 0) P.hist2d(m[in_both, 2], m[in_both, 0], bins=40, norm=LogNorm()) P.xlabel(r'Hutterite Imputed AAF') P.ylabel('EUR AAF') P.title('EUR vs. Hutterite Imputed AAF (#variants = %d)' % (m.shape[0],)) P.colorbar()
def eur_vs_imputed_aaf(m): # Color proportional to #variants P.figure(3) P.clf() in_both = (m[:, 0] > 0) & (m[:, 2] > 0) P.hist2d(m[in_both, 2], m[in_both, 0], bins=40, norm=LogNorm()) P.xlabel(r'Hutterite Imputed AAF') P.ylabel('EUR AAF') P.title('EUR vs. Hutterite Imputed AAF (#variants = %d)' % (m.shape[0], )) P.colorbar()
def make_movie(list): os.system("mkdir movie_plots") for k in range(len(list)): if k < 10: file_name = "img-000"+str(k)+".png" elif k < 100: file_name = "img-00" +str(k)+".png" elif k < 1000: file_name = "img-0" + str(k) +".png" else: file_name = "img-"+str(k) + ".png" plt.hist2d(list[k][0],list[k][1], bins=50) plt.title("Histogram of Generated Distribution") plt.grid(True) plt.savefig(file_name) os.system("mv "+ file_name + " movie_plots") plt.clf()
def bethe_bloch_plot(self): fig, ax = plt.subplots(figsize=(9, 6)) my_cmap = ListedColormap(sns.color_palette("Blues", 50)) fig.set_facecolor('white') h = plt.hist2d(np.log10(self.data_list['Energy (GeV)']), np.log10(self.data_list['Charge per unit length']), bins=[np.linspace(-1., 5., 14), np.linspace(1.5, 3.5, 35)], cmin=1., cmap=my_cmap) plt.colorbar(label="Number of Events") plt.title("Muon Losses") #plt.plot(np.log10(E_array), np.log10(muon_BB), c='r', label="Bethe-Bloch", lw=3) plt.ylabel(r'$\log (\frac{dQ}{dx} \times \frac{0.9 \mu m}{q_{e}})$', fontsize=26) plt.xlabel('$\log$( $E_{\mu}$ / MeV) ') plt.xlim(0, 4.2) plt.ylim(1.5, 3.25) plt.show()
def p2d(x, y, x_bins, y_bins, mode='hist'): if mode == "scatter": plt.scatter(x, y, s=5) elif mode == 'hist': return plt.hist2d(x, y, bins=( x_bins, y_bins, )) elif mode == 'contour': h2, a, b = np.histogram2d(x, y, bins=( x_bins, y_bins, )) plt.contourf( a[:-1], b[:-1], np.transpose(h2), #levels=np.logspace(np.log10(h2.max()/1000.), np.log10(h2.max()), 100) levels=np.linspace(0, h2.max(), 100))
def bethe_bloch_plot(self): me = .511 E_array = np.logspace(-2., 4., 100) BB = [] for E in E_array: if self.pid == 'mu+' or self.pid == 'mu-': BB.append(self.get_dEdx(206.7 * me, E, 1., self.pid)) elif self.pid == 'e+' or self.pid == 'e-': BB.append(self.get_dEdx(me, E, 1., self.pid)) BB = np.array(BB) #todo: may change this /2 if counting hole charge is possible BB = BB * 1e6 / 2 * (1. / 3.62) * 1e-4 # convert from MeV / cm to electron charge per um fig, ax = plt.subplots(figsize=(9, 6)) my_cmap = ListedColormap(sns.color_palette("Blues", 50)) fig.set_facecolor('white') h = plt.hist2d(np.log10(self.data_list['Energy (GeV)']), np.log10(self.data_list['Charge per unit length']), bins=[np.linspace(-1., 5., 14), np.linspace(1.5, 3.5, 35)], cmin=1., cmap=my_cmap) plt.colorbar(label="Number of Events") plt.title(str(self.pid) + " Losses") plt.plot(np.log10(E_array), np.log10(BB), c='r', label="Bethe-Bloch", lw=3) plt.ylabel(r'$\log (\frac{dQ}{dx} \times \frac{0.9 \mu m}{q_{e}})$', fontsize=26) plt.xlabel('$\log$( $E_{' + str(self.pid) + '}$ / MeV) ') #plt.xlim(-2, 4.2) #plt.ylim(1.5, 3.25) plt.show()
drlv_bins = np.linspace(0, tol, nbins) ng = int(d.labels.max()) + 1 drlv = np.sqrt(d.drlv2) dp5 = [drlv[d.labels == i] for i in range(ng)] hl = [np.histogram(dpi, drlv_bins)[0] for dpi in dp5] print("hl0:", hl[0].shape, drlv_bins.shape) if drlv_bins.shape[0] != hl[0].shape[0]: plotbins = (drlv_bins[1:] + drlv_bins[:-1]) / 2 pl.subplot(211) for i in range(ng): pl.plot(plotbins, hl[i], label=str(i)) if 1: print(" " * 10, end=' ') for j in range(ng): print("%5d" % (j), end=' ') print() for i in range(len(drlv_bins) - 1): print("%10.6f" % (drlv_bins[i]), end=' ') for j in range(ng): print("%5d" % (hl[j][i]), end=' ') print() pl.subplot(212) pl.hist2d(drlv, d.labels, (drlv_bins, np.arange(-0.5, ng, 1.)), vmin=0.5) pl.colorbar() pl.ylabel("Grain") pl.xlabel("drlv") pl.show()
# model_snowline.append(np.nanmean(dem_y[np.logical_and(model_scd_y > 110, model_scd_y < 130)])) # modis_snowline.append(np.nanmean(dem_y[np.logical_and(modis_scd_y > 110, modis_scd_y < 130)])) # plt.plot(modis_snowline, np.arange(4.7e6, 6.2e6, 5.e4) + 2.5e4) # plt.plot(model_snowline, np.arange(4.7e6, 6.2e6, 5.e4) + 2.5e4) # plt.grid() # plt.legend() # plt.ylabel('NZTM northing (m)') # plt.xlabel('Elevation (m)') # plt.tight_layout() # plt.savefig(r'C:\Users\conwayjp\OneDrive - NIWA\projects\CARH2101\snow reanalysis\snowline elevation with northing.png',dpi=300) fig1 = plt.figure(figsize=[4, 4]) h2d = plt.hist2d(modis_scd.ravel()[~np.isnan(modis_scd.ravel())], nztm_dem.ravel()[~np.isnan(modis_scd.ravel())], bins=(np.arange(0, 420, 30), np.arange(0, 4000, 200)), norm=LogNorm()) plt.colorbar() plt.xticks(h2d[1][:-1]) plt.yticks(h2d[2][:-1]) plt.ylabel('Elevation (m)') plt.xlabel('SCD (days)') plt.title('(b) MODIS SCD by elevation', fontweight='bold', fontsize=10) mode_modis = np.argmax(h2d[0], axis=0) scd_x = h2d[1][:-1] mode_modis_scd = np.asarray([scd_x[m] for m in mode_modis]) mode_modis_scd += 15 # plt.scatter(mode_modis_scd,h2d[2][:-1]+100,18,'k') plt.scatter(mode_modis_scd, h2d[2][:-1] + 100, 18, 'k', label='mode (MODIS)') plt.legend(loc='upper left') plt.tight_layout()
print "==================" print "best fit slope:" pstats(mh) print "best fit normalization (pivoted) to ", ay pstats(ch) print "best fit scatter in y direction:" pstats(sh) print "==================" # # plot results: # plt.rc('font', family='sans-serif', size=16) fig = plt.figure(figsize=(6, 10)) plt.subplot(211) plt.title('Metropolis') plt.plot(chain) ax = plt.subplot(212) plt.hist2d(mh, ch, bins=60, norm=LogNorm(), normed=1) plt.colorbar() plt.legend(loc='upper center') plt.ylabel('c') plt.xlabel('m') plt.show()
def comparar_gas_ideal(T, r="0", zoom=False): n = len(pairs) dq = np.zeros(Nreps * n, dtype=np.float32) dp = np.zeros(Nreps * n, dtype=np.float32) for i in range(Nreps): sim_q = np.random.random(3 * 1000) * L sim_p = np.random.normal(0, 1, 3 * 1000) * np.sqrt(m * T) * factor_p sim_q = np.array(sim_q, dtype=np.float32) sim_p = np.array(sim_p, dtype=np.float32) dq[n * i:n * (i + 1)], dp[n * i:n * (i + 1)] = deltas(sim_q, sim_p) plt.figure() counts, xbins, ybins, image = plt.hist2d(dq, dp, bins=200, norm=LogNorm(), cmap=plt.cm.rainbow) new_counts = scipy.ndimage.filters.gaussian_filter(counts, 1) plt.colorbar() CS = plt.contour(new_counts.transpose(), extent=[xbins[0], xbins[-1], ybins[0], ybins[-1]], linewidths=3, colors="black", levels=np.logspace(1, 2, 2)) plt.clabel(CS, colors="black", inline=True, fmt="%d", fontsize=20) plt.xlabel(r'$\Delta q$ [fm]', fontsize=14) plt.ylabel(r'$\Delta p$ [MeV/c]', fontsize=14) plt.title(r'Gas ideal - $\rho^*=%1.3f$ - $T=%1.4fMeV$' % (qo**3 * N / V, T), fontsize=16) plt.axis([0, np.sqrt(3) * L / 2, 0, 4000]) plt.grid() if (zoom): plt.axis([0, 4 * qo, 0, 4 * po * factor_p]) # DORSO rho = "rho" + r data = np.loadtxt(rho + "/histograma_2D_%f.txt" % T) xbins = data[0, 1:] ybins = data[1:, 0] counts = data[1:-1, 1:-1] Nbins_2D = len(xbins) - 1 dq = [] dp = [] for x in range(len(xbins) - 1): for y in range(len(ybins) - 1): for i in range(int(counts[x, y])): dq.append((xbins[x + 1] + xbins[x]) * 0.5) if (rho[0] != "M"): dp.append((ybins[y + 1] + ybins[y]) * 0.5 * factor_p) else: dp.append((ybins[y + 1] + ybins[y]) * 0.5) plt.figure() counts, xbins, ybins, image = plt.hist2d(dq, dp, bins=Nbins_2D, norm=LogNorm(), cmap=plt.cm.rainbow) new_counts = scipy.ndimage.filters.gaussian_filter(counts, 1) plt.colorbar() CS = plt.contour(new_counts.transpose(), extent=[xbins[0], xbins[-1], ybins[0], ybins[-1]], linewidths=3, colors="black", levels=np.logspace(1, 2, 2)) plt.clabel(CS, colors="black", inline=True, fmt="%d", fontsize=20) plt.xlabel(r'$\Delta q$ [fm]', fontsize=14) plt.ylabel(r'$\Delta p$ [MeV/c]', fontsize=14) plt.title(r'Dorso - $\rho^*=%1.3f$ - $T=%1.4fMeV$' % (qo**3 * N / V, T), fontsize=16) plt.axis([0, np.sqrt(3) * L / 2, 0, 4000]) plt.grid() if (zoom): plt.axis([0, 4 * qo, 0, 4 * po * factor_p]) plt.show() return dq, dp
diff = abs(t - ht) xh = float(line[1]) yh = float(line[2]) zh = float(line[3]) f.close() x = x - xh y = y - yh z = z - zh #plt.figure(figsize=(20,6)) plt.subplot(131) #plt.scatter(x,y,c=colors[j], marker=shapes[j]) plt.hist2d(x,y,bins=(xbins,xbins),norm=LogNorm()) plt.xlabel(r'$x$ (kpc/$h$)',fontsize=18) plt.ylabel(r'$y$ (kpc/$h$)',fontsize=18) plt.xlim(-200,200) plt.ylim(-200,200) plt.subplot(132) #plt.scatter(x,z,c=colors[j], marker=shapes[j]) plt.hist2d(x,z,bins=(xbins,xbins),norm=LogNorm()) plt.xlabel(r'$x$ (kpc/$h$)',fontsize=18) plt.ylabel(r'$z$ (kpc/$h$)',fontsize=18) plt.xlim(-200,200) plt.ylim(-200,200) plt.subplot(133)
def compute_color_priority(self): """ Compute the color priority :return: """ print(" -- Compute color priority ...") # Load the gamut points location quantized_ab = np.load(os.path.join(self._data_dir, "pts_in_hull.npy")) if self._make_plot: plt.figure(figsize=(15, 15)) grid_spec = gridspec.GridSpec(1, 1) ax = plt.subplot(grid_spec[0]) for i in range(quantized_ab.shape[0]): ax.scatter(quantized_ab[:, 0], quantized_ab[:, 1]) ax.annotate(str(i), (quantized_ab[i, 0], quantized_ab[i, 1]), fontsize=6) ax.set_xlim([-110, 110]) ax.set_ylim([-110, 110]) # Compute the color priority over a subset of the training set with h5py.File(os.path.join(self._data_dir, "HDF5_data_{}.h5".format(self._img_size)), "a") as hf_handler: x_ab = hf_handler["training_lab_data"][:100000][:, 1:, :, :] x_a = np.ravel(x_ab[:, 0, :, :]) x_b = np.ravel(x_ab[:, 1, :, :]) x_ab = np.vstack((x_a, x_b)).T if self._make_plot: plt.hist2d(x_ab[:, 0], x_ab[:, 1], bins=100, norm=LogNorm()) plt.xlim([-110, 110]) plt.ylim([-110, 110]) plt.colorbar() plt.show() plt.clf() plt.close() # Create nearest neighbor instance with index = quantized_ab nearest_neighbor = 1 nearest = nn.NearestNeighbors(n_neighbors=nearest_neighbor, algorithm="ball_tree").fit(quantized_ab) # Find index of nearest neighbor for x_ab distance, index = nearest.kneighbors(x_ab) # We now count the number of occurrences of each color index = np.ravel(index) counts = np.bincount(index) indexes = np.nonzero(counts)[0] priority_probability = np.zeros((quantized_ab.shape[0])) for i in range(quantized_ab.shape[0]): priority_probability[indexes] = counts[indexes] # We turn this into a color probability priority_probability = priority_probability / (1.0 * np.sum(priority_probability)) # Save the probability np.save(os.path.join(self._data_dir, "DataSet_prior_probability_{}.npy".format(self._img_size)), priority_probability) if self._make_plot: plt.hist(priority_probability, bins=100) plt.yscale("log") plt.show()
def pairgrid_heatmap(x, y, **kws): cmap = sns.light_palette(kws.pop("color"), as_cmap=True) plt.hist2d(x, y, cmap=cmap, cmin=1, **kws)
def compute_prior_prob(image_files, width, height, do_plot, pts_in_hull_path, prior_prob_path): """ Compute color prior probabilities for pts in hull Reference: https://github.com/foamliu/Colorful-Image-Colorization/blob/master/class_rebal.py Usage: df_data = pd.read_hdf(os.path.join(data_dir, "preprocessing", "DIV2K", "div2k.hdf5"), "data") list_types = ["'train'"] df_select_data = df_data.query("type in [" + ",".join(list_types) + "]") image_dir = os.path.join(dataset_dir, "DIV2K").replace("\\", "/") image_files = image_dir + "/" + df_select_data["path"].values image_files[0:3], len(image_files) info = dict( image_files = image_files, pts_in_hull_path = os.path.join(data_dir, "colorization_richard_zhang", "pts_in_hull.npy"), prior_prob_path = os.path.join(data_dir, "preprocessing", "DIV2K", "prior_prob_train_div2k.npy"), width = 112, height = 112, do_plot = True ) locals().update(**info) prior_prob = compute_prior_prob(**info) """ # Load ab image X_ab = [] for image_path in tqdm.tqdm(image_files): result = read_image(image_path, is_resize=True, width=width, height=height) X_ab.append(result["res_img_Lab"][:, :, 1:]) # for X_ab = np.array(X_ab) X_ab = X_ab - 128.0 # Load the gamut points location q_ab = np.load(pts_in_hull_path) if do_plot: plt.figure(figsize=(8, 8)) plt.title("ab quantize") gs = gridspec.GridSpec(1, 1) ax = plt.subplot(gs[0]) for i in range(q_ab.shape[0]): ax.scatter(q_ab[:, 0], q_ab[:, 1]) ax.annotate(str(i), (q_ab[i, 0], q_ab[i, 1]), fontsize=6) ax.set_xlim([-110, 110]) ax.set_ylim([-110, 110]) # for # if npts, c, h, w = X_ab.shape X_a_ravel = np.ravel(X_ab[:, :, :, 0]) X_b_ravel = np.ravel(X_ab[:, :, :, 1]) X_ab_ravel = np.vstack((X_a_ravel, X_b_ravel)).T if do_plot: plt.title("Prior Distribution in ab space\n", fontsize=16) plt.hist2d(X_ab_ravel[:, 0], X_ab_ravel[:, 1], bins=100, density=True, norm=LogNorm(), cmap=plt.cm.jet) plt.xlim([-120, 120]) plt.ylim([-120, 120]) plt.xticks(fontsize=12) plt.yticks(fontsize=12) plt.xlabel("b channel", fontsize=14) plt.ylabel("a channel", fontsize=14) plt.colorbar() plt.show() plt.clf() plt.close() # if # Create nearest neighbord instance with index = q_ab NN = 1 nearest = nn.NearestNeighbors(n_neighbors=NN, algorithm='ball_tree').fit(q_ab) # Find index of nearest neighbor for X_ab dists, ind = nearest.kneighbors(X_ab_ravel) # We now count the number of occurrences of each color ind = np.ravel(ind) counts = np.bincount(ind) idxs = np.nonzero(counts)[0] prior_prob = np.zeros((q_ab.shape[0])) prior_prob[idxs] = counts[idxs] # We turn this into a color probability prior_prob = prior_prob / (1.0 * np.sum(prior_prob)) # Save if prior_prob_path is not None: save_dir = os.path.dirname(prior_prob_path) if save_dir != "" and os.path.exists(save_dir) == False: os.makedirs(save_dir) pts_in_hull_name = os.path.basename(pts_in_hull_path) safe_copy(pts_in_hull_path, os.path.join(save_dir, pts_in_hull_name)) np.save(prior_prob_path, prior_prob) # if if do_plot: plt.hist(prior_prob, bins=100) plt.xlabel("Prior probability") plt.ylabel("Frequency") plt.yscale("log") plt.show() # if return prior_prob pass
#A = F_star/F_prev U = np.random.uniform() if U < A: y[i] = x2_star i = i + 1 x2_prev = x2_star else: y[i] = x2_prev x2_prev = y[i] i = i + 1 # PLOTTING plt.figure(figsize=[12, 12]) counts, xd, yd, fig = plt.hist2d(x, y, 31, cmap="Purples") #or try plt.hexbin(x,y, cmap="Purples") xt, yt = np.meshgrid(np.linspace(-3, 3, 100), np.linspace(-3, 3, 100)) plt.contour(xt, yt, np.exp(-xt**2 / 2) * np.exp(-yt**2 / 2)) plt.scatter(x, y, 0.1, alpha=0.2, cmap="BuGn") # Yeah, I just can't figure out how to do these multivariate problems - I had the same problem with last week's homework. I think that I'm not setting up my proposal choices of x_star and y_star correctly, especially when the proposal function is not a simple normal or uniform. I also don't really know how the 2D contour plot should be set-up. I just saw the solution from HW3 was posted and tried adapting that but ran out of time. # In[126]: x_mean = np.mean(x) y_mean = np.mean(y) np.std(x)
#if (modelnames[m] != 'Persist'): y_pred = (model.predict(X_test)).ravel() #else: # y_pred = np.roll(y_test.ravel(),1) y_preds[m,:] = y_pred.ravel() rms[m] = np.mean((y_pred-y_test)*(y_pred-y_test)) residuals = y_pred-y_test gherkin = {"y_test":y_test, "y_pred":y_pred.ravel(), "residuals":residuals} # Bala, insert code here to calculate p values for residual pickle.dump( gherkin , open( "{0}/{1}_fit_residuals.pkl".format(dir,modelnames[m]), "wb" ) ) print(modelnames[m], rms[m]) f.write("{0}: {1:02d} {2:7.4f} {3:7.4f}\n".format(modelnames[m], lookforward, rms[m], np.mean((y_pred[27000:45000]-y_test[27000:45000])*(y_pred[27000:45000]-y_test[27000:45000])))) plt.hist2d(kp_unscale(y_test), kp_unscale(y_preds[m,:]), range=[[0,9],[0,9]], bins=[10,10], norm=LogNorm()) plt.title(modelnames[m]) plt.savefig('{0}/kp_regress_model_{1}.jpg'.format(dir,modelnames[m])) f.close() # In[167]: #for m in range(len(models)): # plt.hist2d(kp_unscale(y_test), kp_unscale(y_preds[m,:]))#,norm=LogNorm()) # plt.xlim(0,9) # plt.ylim(0,9) # plt.title(modelnames[m]) # plt.colorbar() #plt.show() # plt.savefig('{0}/kp_regress_hist2d_{1}.jpg'.format(dir,modelnames[m]))
def plot_chain2d(xh, yh, x0, y0, Rxval, Ryval, nRval=None, modelpdf=None, params=[]): from matplotlib import pylab as plt from matplotlib.colors import LogNorm import scipy.optimize as opt x = np.arange(np.min(xh) - 1.0, np.max(xh) + 1, 0.05) y = np.arange(np.min(yh) - 1.0, np.max(yh) + 1, 0.05) X, Y = np.meshgrid(x, y) xs = np.array(zip(X, Y)) Z = modelpdf(xs, params=params) plt.rc('font', family='sans-serif', size=16) fig = plt.figure(figsize=(15, 15)) plt.subplot(221) plt.title('Gelman-Rubin indicator') #plt.plot(chain) plt.yscale('log') iterd = np.linspace(0, len(xh) - 1) xp = nRval * np.arange(np.size(Rxval)) #print "x, Rxval:", np.size(xp), np.size(Rxval) plt.plot(xp, Rxval) plt.plot(xp, Ryval) ax = plt.subplot(222) plt.hist2d(xh, yh, bins=100, norm=LogNorm(), normed=1) plt.colorbar() dlnL2 = np.array( [2.30, 9.21]) # contours enclosing 68.27 and 99% of the probability density xc = np.zeros([1, 2]) Lmax = modelpdf(xc, params=params) lvls = Lmax / np.exp(0.5 * dlnL2) cs = plt.contour(X, Y, Z, linewidths=(1.0, 2.0), colors='black', norm=LogNorm(), levels=lvls, legend='target pdf') xmin = -4.0 xmax = 4.0 nbins = 80 dx = (xmax - xmin) / nbins dx2 = dx * dx H, xbins, ybins = np.histogram2d(xh, yh, bins=(np.linspace(xmin, xmax, nbins), np.linspace(xmin, xmax, nbins))) H = np.rot90(H) H = np.flipud(H) Hmask = np.ma.masked_where(H == 0, H) H = H / np.sum(H) clevs = [0.99, 0.6827] lvls = [] for cld in clevs: sig = opt.brentq(conf_interval, 0., 1., args=(H, cld)) lvls.append(sig) plt.contour(H, linewidths=(3.0, 2.0), colors='magenta', levels=lvls, norm=LogNorm(), extent=[xbins[0], xbins[-1], ybins[0], ybins[-1]]) plt.title('MCMC samples vs target distribution') labels = ['68.27%', '99%'] for i in range(len(labels)): cs.collections[i].set_label(labels[i]) plt.legend(loc='upper left') plt.ylabel('y') plt.xlabel('x') plt.show()
print(sigma_hat) print(np.linalg.det(sigma_hat)) a = np.zeros([len(label), len(f_x[0])]) for i in range(len(label)): a[i] += f_x[i] print(np.cov(a)) print(np.linalg.det(np.cov(a))) # print('{:.10f}'.format(np.linalg.det(sigma_hat))) # P(f(x)| y=c) = N(f(x)|mu-hat[c], sigma-hat) N = multivariate_normal(mean=mu_hat[0], cov=(sigma_hat + e)) bins = np.arange(0, 1000, 10) plt.hist2d(N, bins) plt.show() # print(distance[i][int(len(data)*(95.0/100.0))-1]) # 95퍼센트 위치에 해당하는 인덱스의 값(근사) # print(np.percentile(data, 95)) # 95% 백분위수 출력(데이터의 95%가 발견되는 기댓값) a = [None] * 10 for i in range(10): a[i] = list() a[i].append(np.percentile(distance[i], 95)) ood_distance = np.array(a) print( "<ODD threshold of Euclidian distance of penultimate logits in each label>" ) print(ood_distance) print()
# regr = linear_model.BayesianRidge() regr = tree.DecisionTreeRegressor() regr.fit(cat_train_X, cat_train_y) cat_target_prediction = regr.predict(cat_target_X) diff = np.array(cat_target_true) - cat_target_prediction np_cat_target_true = np.array(cat_target_true) print "Normalized Median Absolute Deviation :" + str(nmad(diff)) p_outliers = outliers(diff, np_cat_target_true, nmad(diff)) print "Percentage of outliers = " + str(p_outliers) + " %" plt.figure() # plt.hist2d(np.array(cat_target_true), cat_target_prediction, bins=1000) plt.hist2d(np_cat_target_true, diff, bins=1000) plt.title(str(regr)[0:15]) plt.xlabel('z') plt.ylabel('dz') plt.xlim([0., 0.6]) plt.ylim([-0.08, 0.08]) # plt.show() plt.savefig("plots/" + str(regr)[0:13] + ".png") """ model = machine.logistic() model.train(cat_train_X, cat_train_y) cat_target_prediction = model.use(cat_target_X) """ """
plt.ylabel('contas') plt.xlabel(r'$masa \; (\frac{MeV}{c^2})$') plt.grid() plt.figure(4) plt.hist(mA, bins=100, range=(1080, 1140)) plt.title(r'masa $\bar{\Lambda}^0$ datos LHCb') plt.ylabel('contas') plt.xlabel(r'$masa \; (\frac{MeV}{c^2})$') plt.grid() #plot plt.figure(1) plt.plot(x, y, linestyle='None', marker='o', markersize='0.1', color='g', label='datos LHCb') plt.title('Armenteros-Podolanski plot') plt.xlabel(r'$\alpha$') plt.ylabel(r'$P_T \; (\frac{MeV}{c})$') plt.legend(loc='best', markerscale=18) plt.grid() plt.figure(5) plt.hist2d(x, y, bins=100, norm=LogNorm()) plt.title('Armenteros-Podolanski density plot') plt.xlabel(r'$\alpha$') plt.ylabel(r'$P_T \; (\frac{MeV}{c})$') plt.colorbar()
def analyze_activity(activity, lut_merged=None, onlycache=False): #if 'Snow' not in activity['name']: # return cache_key = (activity["id"], "v0") if cache_key in cache: activity['analysis'] = cache[cache_key] print("\033[32min cache!\033[0m") return True if onlycache: return False d_N = 10 if 'streams' not in activity: print("\033[31mno streams!\033[0m") return streams = activity['streams'] try: distance = np.array(streams['distance']['data']) altitude = np.array(streams['altitude']['data']) ttime = np.array(streams['time']['data']) latlng = np.array(streams['latlng']['data']) except Exception as e: print("\033[31mno good data!\033[0m", e) traceback.print_exc() return cadence = None heartrate = None try: cadence = np.array(streams['cadence']['data']) * 2. heartrate = np.array(streams['heartrate']['data']) except Exception as e: print("\033[31mno optional data!\033[0m", e) d_distance = d_(distance, d_N) d_altitude = d_(altitude, d_N) d_d3 = (d_distance**2 + d_altitude**2)**0.5 d_time = d_(ttime, d_N) speed_kph = d_d3 / d_time * 3600. / 1000. vam = d_altitude / d_time grade = d_altitude / d_d3 * 100. def dealias(x): mn = np.round(np.abs(x[x > 0]).min(), 5) print("found step", mn) x += np.random.rand(altitude.shape[0]) * mn - mn / 2. if cadence is not None: dealias(cadence) dealias(d_altitude) dealias(d_distance) speed_kph = d_d3 / d_time * 3600. / 1000. vam = d_altitude / d_time * 1000 grade = d_altitude / d_d3 * 100. m = np.abs(d_altitude) < 1000 m &= np.abs(vam) < 2000 def p2d(x, y, x_bins, y_bins, mode='hist'): if mode == "scatter": plt.scatter(x, y, s=5) elif mode == 'hist': return plt.hist2d(x, y, bins=( x_bins, y_bins, )) elif mode == 'contour': h2, a, b = np.histogram2d(x, y, bins=( x_bins, y_bins, )) plt.contourf( a[:-1], b[:-1], np.transpose(h2), #levels=np.logspace(np.log10(h2.max()/1000.), np.log10(h2.max()), 100) levels=np.linspace(0, h2.max(), 100)) for mode in 'hist', : #'contour': f, (ax1, ax2) = plt.subplots(1, 2, figsize=(9, 5)) lut_speed_grade = p2d( speed_kph[m], #d_altitude[m]/d_time[m]*3600., #60./(d_distance[m]/d_time[m]*3600./1000.), #d_distance[m]/d_time[m]*3600./1000., #d_altitude[m]/d_time[m]*3600., #d_altitude[m]/d_time[m]*3600, grade[m], mode=mode, x_bins=np.linspace(0, 15, 70), y_bins=np.linspace(-60, 60, 70), #y_bins = np.linspace(-2000, 2000, 70), ) #luts.append(lut_speed_grade) plt.subplots_adjust(wspace=0) ax1.scatter( latlng[:, 1], latlng[:, 0], #c=cm.jet(np.array(streams['velocity_smooth']['data'])/6.), c=cm.jet( ( np.array(d_altitude * 3600) / (1000.) #np.array(streams['altitude']['data'])-320)/(600-320) ), )) plt.title(activity['name']) print("total time", (ttime[-1] - ttime[0]) / 3600., "hr") x_grade = np.linspace(-50, 50) ax2.plot( [speed_estim_for_grade(x, lut_speed_grade, (0, 1.)) for x in x_grade], x_grade, c="k", lw=3, ) if lut_merged is not None: ax2.plot([ speed_estim_for_grade(x, lut_merged, (0.3, 0.7)) for x in x_grade ], x_grade, c="r", lw=3, ls=":") if heartrate is not None: plt.figure() plt.hist2d( grade[m], heartrate[m], bins=(np.linspace(-60, 60, 100), np.linspace(0, 200, 100)), ) plt.axvline(8.) _ = estimate_track(d_d3, d_altitude, d_time, ttime, lut_speed_grade, d_N=d_N) total_time_estim = _['total_time_estim'] sum_time = _['sum_time'] _ = estimate_track(d_d3, d_altitude, d_time, ttime, lut_merged, d_N=d_N) total_time_model_estim = _['total_time_estim'] print("total time estimate", total_time_estim / 3600., "hr", "summed time", sum_time / 3600., "hr") print("total time model estimate", total_time_model_estim / 3600., "hr", "summed time", sum_time / 3600., "hr") S = {} activity['analysis'] = S activity['analysis']['modes'] = extract_modes(grade, d_time / (d_N - 1), d_d3 / (d_N - 1), altitude) activity['analysis']['modes_string'] = ",".join([ "%.5lg" % m['time_fraction_pc'] for n, m in sorted(activity['analysis']['modes'].items(), key=lambda x: x[1]['order']) if n is not "all" ]) S['total_time_estimate_s'] = total_time_estim S['total_time_model_estimate_s'] = total_time_model_estim S['summed_time_s'] = sum_time S['lut'] = lut_speed_grade buf = io.BytesIO() plt.savefig(buf, format='png') S['lut_png_b64'] = base64.b64encode(buf.getvalue()) #print("total run fraction", np.sum(m_run)/m_run.shape[0]) #break #ax=plt.gca() #ax2=plt.twiny() #ax2.set_xlim(60./np.array(ax.get_xlim())) #plt.xlabel("pace") #plt.ylabel("grade") #plt.ylabel("VAM") cache[cache_key] = activity['analysis']
diff = abs(t - ht) xh = float(line[1]) yh = float(line[2]) zh = float(line[3]) f.close() x = x - xh y = y - yh z = z - zh #plt.figure(figsize=(20,6)) plt.subplot(131) #plt.scatter(x,y,c=colors[j], marker=shapes[j]) plt.hist2d(x, y, bins=(xbins, xbins), norm=LogNorm()) plt.xlabel(r'$x$ (kpc/$h$)', fontsize=18) plt.ylabel(r'$y$ (kpc/$h$)', fontsize=18) plt.xlim(-200, 200) plt.ylim(-200, 200) plt.subplot(132) #plt.scatter(x,z,c=colors[j], marker=shapes[j]) plt.hist2d(x, z, bins=(xbins, xbins), norm=LogNorm()) plt.xlabel(r'$x$ (kpc/$h$)', fontsize=18) plt.ylabel(r'$z$ (kpc/$h$)', fontsize=18) plt.xlim(-200, 200) plt.ylim(-200, 200) plt.subplot(133) #plt.scatter(y,z,c=colors[j], marker=shapes[j])
import matplotlib as mpl import matplotlib.pylab as plt import numpy as np # #import math end = int(0.1 * fluka1.shape[0]) fig = plt.figure() plt.subplot(121) x = fluka1[0:end, 1] y = fluka1[0:end, 2] plt.hist2d(x, y, bins=100, norm=mpl.colors.LogNorm(), cmap="viridis") #H, xedges, yedges = np.histogram2d(x, y, bins=50, normed = True) # #plt.imshow(H) #H2, _, _ = np.histogram2d(x,y, bins=50) #extent = [0,1, xedges[-1], xedges[0]] #plt.imshow(H/H2) #plt.colorbar() plt.xlabel('x [cm]', fontsize=12) plt.ylabel('y [cm]', fontsize=12) plt.title('Before TPST') cbar = plt.colorbar() #cbar.ax.set_xticklabels(0.10,100)
N = 0 for target in proteins: target = 'T0760' for decoy in tqdm(decoys[target]): decoy_name = decoy[0].split('/')[-1] p_corr_x, p_corr_y = get_correlation(target, decoy_name) corr_x = corr_x + p_corr_x corr_y = corr_y + p_corr_y pearson_prot = stat.pearsonr(p_corr_x, p_corr_y)[0] # for x, y in zip(corr_x, corr_y): # if y<0: # print corr_x # print corr_y # print decoy_name # print target # raise(Exception("RMSD<0")) if not np.isnan(pearson_prot): av_pearson += pearson_prot N+=1 break from matplotlib.colors import LogNorm # pearson_prot = stat.pearsonr(corr_x, corr_y)[0] print av_pearson/N plt.hist2d(corr_x, corr_y, bins=100, range=np.array([(0.1, 5), (0, 10)]), norm=LogNorm()) plt.colorbar() plt.savefig("corr_T0760_lr10A.png")
for k in seleccion: data_aux = np.loadtxt(caso + "distribucion_%f.txt" % (rhos[k]), dtype=np.float32) data_q = data_aux[:, 0] data_p = data_aux[:, 1] plt.figure() for i in range(g): q_temp = np.array(data_q[i * 3 * n:(i + 1) * 3 * n], dtype=np.float32) p_temp = np.array(data_p[i * 3 * n:(i + 1) * 3 * n], dtype=np.float32) dq[i * p:(i + 1) * p], dp[i * p:(i + 1) * p] = deltas( q_temp, p_temp) counts, xbins, ybins, image = plt.hist2d(dq, dp, bins=100, norm=LogNorm(), cmap=plt.cm.rainbow) plt.colorbar() new_counts = scipy.ndimage.filters.gaussian_filter(counts, 1) CS = plt.contour(new_counts.transpose(), extent=[xbins[0], xbins[-1], ybins[0], ybins[-1]], linewidths=3, colors="black", levels=np.logspace(0, 2, 3)) plt.clabel(CS, colors="black", inline=True, fmt="%d", fontsize=20) plt.xlabel(r'$\Delta q$') plt.ylabel(r'$\Delta p$') plt.axis([0, xbins[-1], 0, ybins[-1]]) plt.title(r'$\rho=%1.4f fm^{-3}$' % (rhos[k])) plt.show()
def loadfiles(task): #Load an individual simulation tbegin = time.clock() dirs,files,grp,finalstep = task tfile = dirs + files + '.' + finalstep + '/' + files + '.' + finalstep print(tfile + '.' + grp) s = pynbody.load(tfile) s.physical_units() print("simulation loaded") hs = s.halos() h = hs[int(grp)] print("halos loaded") pynbody.analysis.halo.center(h,mode='com',vel= False) #not as accurate as hyb but saves memory and time print("halo center of mass") #pynbody.analysis.angmom.sideon(h) #print("halo aligned") hrvir = np.max(h.gas['r']) print("Read in .fits files") """ #Read in iords of all particle that have been in the disk disk_iord_file = pyfits.open(dirs + 'grp' + grp + '.reaccrdiskall_iord.fits') #Include those particles that start off in the disk disk_early_iord_file = pyfits.open(dirs + 'grp' + grp + '.earlydisk_iord.fits') """ #Read in iords of all particles that have been in the halo disk_iord_file = fits.open(dirs + 'grp' + grp + '.reaccr_iord.fits') #Include those particles that start off in the halo disk_early_iord_file = fits.open(dirs + 'grp' + grp + '.earlyhalo_iord.fits') disk_iord = disk_iord_file[0].data disk_early_iord = disk_early_iord_file[0].data disk_iord = np.concatenate((disk_iord,disk_early_iord)) indicies = np.in1d(s.star['igasorder'],disk_iord) #Select for star particles in the main simulation that formed out of gas particles once in the disk/halo. disk_parts_star = s.star[np.nonzero(indicies)] #Note that multiple star particles can form from the same gas particle #Merge list of star formed from disk gas with list of all stars in halo at z = 0 iord_disk_parts_star = disk_parts_star['iord'] #stars formed out of gas that was in the halo iord_halo_star = h.star['iord'] #stars in halo at z = 0 iord_stars = np.concatenate((iord_disk_parts_star,iord_halo_star)) #concatenate arrays of iord temp, indices = np.unique(iord_stars, return_index=True) #remove duplicate stars iord_stars = iord_stars[indices] #Array of gas iords and star iords iord_all = np.concatenate((disk_iord,iord_stars)) #concatenate arrays of iord indicies = np.in1d(s['iord'],iord_all) disk_parts = s[np.nonzero(indicies)] #Note, many of the gas particles in disk_iord will have been deleted by z = 0 because of star formation #Calculate metallicity of gas and stars from O and Fe and the radius disk_parts.gas['metalMassFrac'] = 2.09*disk_parts.gas['OxMassFrac'] + 1.06*disk_parts.gas['FeMassFrac'] disk_parts.star['metalMassFrac'] = 2.09*disk_parts.star['OxMassFrac'] + 1.06*disk_parts.star['FeMassFrac'] disk_parts.dark['metalMassFrac'] = 0 disk_parts['rad'] = np.sqrt(disk_parts['x']**2 + disk_parts['y']**2 + disk_parts['z']**2) # Goal: for any particle that is out of the halo at z = 0, use its metallicity at the time it left the halo, rather than its current metallicity reoutflow_iord_file = fits.open(dirs + 'grp' + grp + '.reoutflow_iord.fits') #All gas that exited the disk after having been in it reoutflow_iord = reoutflow_iord_file[0].data reoutflow_iord_rev = reoutflow_iord[::-1] temp, indices = np.unique(reoutflow_iord_rev, return_index=True) #indicies corresponding to unique outflow particles reoutflow_iord_rev_uniq = reoutflow_iord_rev[indices] reoutflow_met_file = fits.open(dirs + 'grp' + grp + '.reoutflow_history.fits') reoutflow_met = reoutflow_met_file[1].data['metallicity'] reoutflow_met_rev = reoutflow_met[::-1] reoutflow_met_rev_uniq = reoutflow_met_rev[indices] # Select for only those outflowing particles that are gasous and outside of the halo at z = 0 indicies = np.in1d(reoutflow_iord_rev_uniq,s['iord']) reoutflow_iord_rev_uniq = reoutflow_iord_rev_uniq[np.nonzero(indicies)] #Only those particles that are gasous at z = 0 reoutflow_met_rev_uniq = reoutflow_met_rev_uniq[np.nonzero(indicies)] #Choice of whether adjusting the metallicities of those particles not in the disk or only those particles not in the halo. if 0: indicies = np.in1d(reoutflow_iord_rev_uniq,h['iord'],invert = 1) #only those particles that are not in the halo reoutflow_iord_rev_uniq_out = reoutflow_iord_rev_uniq[np.nonzero(indicies)] reoutflow_met_rev_uniq_out = reoutflow_met_rev_uniq[np.nonzero(indicies)] else: reoutflow_iord_rev_uniq_out = reoutflow_iord_rev_uniq reoutflow_met_rev_uniq_out = reoutflow_met_rev_uniq #Select all particles that were in the halo but then leave it #to make sure that all gas particles in outflow were once accreted (debugging) disk_iord_uniq = np.unique(disk_iord) indicies = np.in1d(disk_iord_uniq,reoutflow_iord_rev_uniq) print(len(reoutflow_iord_rev_uniq)) print(len(disk_iord_uniq[np.nonzero(indicies)])) indicies = np.in1d(reoutflow_iord_rev_uniq,disk_iord_uniq) print(len(reoutflow_iord_rev_uniq[np.nonzero(indicies)])) #Why do these arrays not have the same length?! #Why are there particles in reoutflow that aren't in reaccr or early_halo?! # Replace their metallicity # Matching particles in the outflow to those in disk_iord iord_intersect = np.intersect1d(disk_parts['iord'],reoutflow_iord_rev_uniq_out) #Find the iords of the elements in common a = disk_parts['iord'] b = reoutflow_iord_rev_uniq_out intersect = np.intersect1d(a,b) asort = np.argsort(a) a_ind = np.searchsorted(a,intersect,sorter = asort) bsort = np.argsort(b) b_ind = np.searchsorted(b,intersect,sorter = bsort) inda = asort[a_ind] indb = bsort[b_ind] # Debugging plot to make sure that z = 0 and exiting metallicities are reasonable similar fig = plt.figure(7) temp = plt.hist2d(np.log10(np.array(disk_parts[inda]['metalMassFrac'])),np.log10(reoutflow_met_rev_uniq_out[indb]),bins = 400) plt.xlabel('log z = 0 Metallicity') plt.ylabel('log Metallicity when expelled') plt.plot([-9,0],[-9,0],color = 'k') disk_parts[inda]['metalMassFrac'] = reoutflow_met_rev_uniq_out[indb] #Make images outfilebase = dirs + files + '.grp' + grp print('Disk particles selected, now write to ' + outfilebase) outflowImages(s,disk_parts,hrvir,outfilebase) pltZvsR(disk_parts,hrvir,outfilebase) print 'Memory usage: %s (kb)' % resource.getrusage(resource.RUSAGE_SELF).ru_maxrss tend = time.clock() print 'Time elapsed: %f ' % (float(tend) - float(tbegin))
f00 = plt.figure() N, bins, patches = plt.hist(z, bins=61) """ for i in range(0,20): patches[i].set_facecolor('b') for i in range(20,40): patches[i].set_facecolor('r') for i in range(40, len(patches)): patches[i].set_facecolor('b') """ plt.xlabel("z in meter") f0 = plt.figure() plt.hist2d(z, dE, bins=[50, 50]) plt.xlabel("z in meter") plt.ylabel("dE/E in sigmadE/E") c = plt.colorbar() c.set_label('number of particles', rotation=270) f01 = plt.figure() plt.hist(x, bins=200) plt.xlabel("x in sig_x") f02 = plt.figure() plt.hist(y, bins=200) plt.xlabel("y in sig_y") f1 = plt.figure()
snr=20, dgd=10e-12, freq_off=00e6, lwdth=000e3, roll_frame_sync=True, modal_delay=[2000, 3000]) mysig3.sync2frame() print(mysig3.shiftfctrs) mysig3.corr_foe() wxy, eq_sig = equalisation.pilot_equaliser(mysig3, (1e-3, 1e-3), 45, foe_comp=False, methods=("cma", "sbd_data")) cpe_sig, ph = phaserec.pilot_cpe(eq_sig, N=5, use_seq=False) #cpe_sig = eq_sig print(cpe_sig.cal_gmi()) plt.figure() plt.subplot(121) plt.hist2d(cpe_sig[0].real, cpe_sig[0].imag, bins=200) #plt.plot(wxy[0][0].real, '-k') #plt.plot(wxy[0][1].real, '--k') #plt.plot(wxy[0][0].imag, '-c') #plt.plot(wxy[0][1].imag, '--c') plt.subplot(122) plt.hist2d(cpe_sig[1].real, cpe_sig[1].imag, bins=200) #plt.plot(wxy[1][0].real, '-k') #plt.plot(wxy[1][1].real, '--k') #plt.plot(wxy[1][0].imag, '-c') #plt.plot(wxy[1][1].imag, '--c') plt.show()
import numpy as np import astropy from astropy import wcs from astropy.io import fits from astropy.table import Table import matplotlib.pylab as plt field = np.sys.argv[1] x = fits.open('w'+field+'_rand_xy_mask.fits') index = x[1].data['flag']==1 bins = 500 r1,r2 = np.count_nonzero(index),x[1].data['flag'].shape[0] print(r1*1./r2) plt.hist2d(x[1].data['ra'][index],x[1].data['dec'][index],bins=(bins,bins))
def func_plot_cfhist(dat_string, goal_var, input_var, train_fraction=0.6, rel_flag=0, max_depth_in=None): # TODO:rename train_fraction, its actually eval fraction # Applies a decisiontreeregressor returns a 2d hist plots # rel_flag: Since relative humidity is not part of the douze data it is calculated here and added according to this flat # rel_flag = 1, adds rel_hum # rel_flag = 2, adds qvlm_sqsm (qt-sat) # TODO: get rid of default rel_flag=0!! it will cause an error # Loading data data = Dataset(dat_string) # .ravel returns a masked flattened array # but all values are actually unmasked at this point # FLATTEN INPUT 2D ARRAY TO 1D MASKED ARRAY # TODO: add user-defined function flatten , flatten(variable) # y - e.g. LES cloud fraction,'True' values to compare with y = data.variables[goal_var][:].ravel() # FOR ALL INPUT VARIABLES' NAMES for input in input_var: # FLATTEN ARRAY 2D -> 1D x_temp = data.variables[input][:].ravel() # if input is the first in a list input fields # TODO: ask Philipp whats the point of this conditional?, use enumerate instead? if input == input_var[0]: X = x_temp else: #vstack concacenates row array into 2d array, by putting one (1,N) on top of the other # APPEND a new 1xN row on every step X = np.vstack([X, x_temp]) input_var_tmp = input_var.copy() # print(input_var_tmp) # Add relative humidity if rel_flag == 1: # qvlm - mean liquid water + vapor # qsm - mean saturation mixing ratio? rel_sat = data.variables['qvlm'][:].ravel( ) / data.variables['qsm'][:].ravel() X = np.vstack([X, rel_sat]) input_var_tmp.append('rel_sat') if rel_flag == 2: # TODO: qvlm, qsm are hardcoded here! Make them an explicit function input! # qvlm - liquid and gas water content, [kg/kg]? # qvl_qs the saturation deficit when qvlm is smaller than qsm qvl_qs = data.variables['qvlm'][:].ravel( ) - data.variables['qsm'][:].ravel() X = np.vstack([X, qvl_qs]) input_var_tmp.append('qvl_qs') # print(input_var_tmp) # TODO: train_fraction is a fraction of true cloud fraction LES values to train on? n_e = int(len(y) * train_fraction) # or return a permuted range len= p = np.random.permutation(len(y)) # TODO: variables below declared, but not called. Delete? y_shuf = y[p] X_shuf = X[:, p] #TODO: pick the train part randomly(not succesively) from y vector? y_train = y[n_e:] y_eval = y[:n_e] X_train = X[:, n_e:] X_eval = X[:, :n_e] X_train = X_train.transpose() X_eval = X_eval.transpose() # Now we set up and train the decision tree regressor # max_depth – The maximum depth of the tree. If None, then nodes are expanded # until all leaves are pure or until all leaves contain less than min_samples_split samples. regr_1 = tree.DecisionTreeRegressor(max_depth=max_depth_in) # Build a decision tree regressor from the training set (X, y) regr_1.fit(X_train, y_train) # Now the prediction magic happens y_pred = regr_1.predict(X_eval) # TODO: actually use array masking to increase performance. y_pred is a masked array, but has no masked entries! fig = plt.figure(figsize=(10, 10)) bla = plt.hist2d(y_eval, y_pred, bins=100, norm=LogNorm()) plt.colorbar() # bla = plt.hist2d(rel_sat,cl_l,bins=100, norm=LogNorm()) # bla = plt.plot(sat_x,sat_ave,color='w',linewidth=2) # plt.vlines(1,0,1,'k') return fig
def HIST2D(self, BinsHist, gaus_peak, SDOM_num): #plotting 2D histogram of time residuals vs timestamps plt.figure(figsize=(12, 12)) keep = self.rising_a_elim_3 >= 0 self.abs_elim = self.abs_elim_3[keep] + self.rising_a_elim_3[keep] self.weights_keep = self.weights[keep] x = self.abs_elim y = self.abs_elim % gaus_peak #Log-scale h, self.xedges, self.yedges, img = plt.hist2d( x, y, BinsHist, #[np.linspace(0.0e10,0.2e10, 150), np.linspace(97620, 102000, 150)], #[np.linspace(2.68e10, 3e10, 150), np.linspace(13410, 13500, 150)], #cmin = 4 , norm=LogNorm()) cb = plt.colorbar() plt.xlabel('timestamps') plt.ylabel('time residuals') #No log-scale plt.figure(figsize=(12, 12)) h, self.xedges, self.yedges, img = plt.hist2d( x, y, BinsHist, #[np.linspace(0.0e10,0.2e10, 150), np.linspace(97620, 102000, 150)], #[np.linspace(2.68e10, 3e10, 150), np.linspace(13410, 13500, 150)], #cmin = 4 , #norm = LogNorm() ) cb = plt.colorbar() plt.xlabel('timestamps') plt.ylabel('residuals') #the loop scans the graph to find the brightest bins - the brightest bins (ie bins with more events) generally correspond to the POCAM events self.POCAM_bins = ([]) #stores the bins that contain POCAM events for j in range(0, BinsHist): #print(j, j+1) bins = h[j:j + 1, 0:].flatten() max_ind = np.argmax(bins) #selecting the brightest bin #moving along x-axis the POCAM_bins correspond to the bin number along y_axis self.POCAM_bins = np.append(self.POCAM_bins, max_ind) POCAM_diff = abs( self.POCAM_bins[1:] - self.POCAM_bins[:-1] ) #Subtracting the brightest bin number to observe where the jumps in time residuals have occurred #Conditions for selecting runs according to each sDOM if SDOM_num == ['SDOM5']: #Mode = mode(POCAM_diff[POCAM_diff > 1]) #in case this doesn't work use Mode = 1 Mode = 1 jump_index = np.where( (POCAM_diff > Mode - 25) * (POCAM_diff < Mode + 25)) if SDOM_num == ['SDOM1']: Mode = 1 jump_index = np.where( (POCAM_diff > Mode - 25) * (POCAM_diff < Mode + 25)) if SDOM_num == ['SDOM2']: Mode = 1 jump_index = np.where( (POCAM_diff > Mode - 25) * (POCAM_diff < Mode + 25)) if SDOM_num == ['SDOM3']: Mode = 1 jump_index = np.where( (POCAM_diff > Mode - 25) * (POCAM_diff < Mode + 25)) self.JumpIndex = (np.array(jump_index).flatten()) + 1 #print(self.JumpIndex) plt.plot( self.POCAM_bins, '.' ) #plotting POCAM_bins as a scatter plot to check if the right bins are bein picked self.gaus_peak = gaus_peak #storing gaus_peak value as self.gaus_peak to use for calc_res function return self.abs_elim, BinsHist, self.JumpIndex, self.xedges, self.yedges, self.POCAM_bins, POCAM_diff
import matplotlib.pylab as plt import numpy as np import pandas as pd from matplotlib import cm from scipy.stats import norm, chi2, binom, gamma import seaborn as sns from math import cos, sin, log, tan, pi, exp, sqrt, cosh, sinh, tanh, atan, atan2 for i in range(510): p = plt.figure(figsize=(13, 13), facecolor='black', dpi=100) p = plt.axis('off') x, y = np.random.normal(0, 1, i**2 + 20), np.random.normal(0, 1, i**2 + 20) p = plt.hist2d(x, y, bins=100, cmap='afmhot') p = plt.savefig( f'C:/Users/Alejandro/Pictures/RandomPlots/20042020/plot{i}.PNG', facecolor='black')
def showL11(self, sKey='vPhiObs'): """Plots loebman et al. 2011""" plt.figure(1, figsize=(8,4)) plt.clf() plt.scatter(self.tSim['FeH'][self.bSel], \ self.tSim[sKey][self.bSel], \ alpha=0.25, s=4, edgecolor='None') # set the title sTitle = '(%.2f <= R < %.2f) ; (%.2f <= |Z| < %.2f); (%.1f <= Age < %.1f)' \ % (self.RMin, self.RMax, self.ZMin, self.ZMax, self.AgeMin, self.AgeMax) if self.useFlatUncertainty: sTitle = '%s - PM error %.2f mas/yr' % (sTitle, self.uncPM) plt.suptitle(sTitle, fontsize=12) plt.xlabel(r"$\left[ \frac{Fe}{H} \right]$", fontsize=14) plt.ylabel(r"$v_{\phi}$, km s$^{-1}$", fontsize=14) bStrips = (self.stripCounts > 10) plt.errorbar(self.stripFeHs[bStrips], \ self.stripMeans[bStrips], \ yerr=self.stripStdds[bStrips], \ ecolor='k', fmt='yo', zorder=5) plt.scatter(self.stripFeHs[bStrips], \ self.stripMeans[bStrips], \ color=self.stripCounts[bStrips], \ s=36, edgecolor='y', \ cmap=plt.cm.get_cmap('cubehelix'), zorder=15) plt.colorbar() if sKey.find('Phi') > -1: dum = plt.hist2d(self.tSim['FeH'][self.bSel], \ self.tSim[sKey][self.bSel], \ bins=(75, 75), \ range=[[-1.5,0.5], [-350., -50.]], \ alpha=0.5, zorder=2) plt.colorbar() plt.xlim(-1.5,0.5) if sKey.find('Phi') > -1: plt.ylim(-50., -350.) if sKey.find('mu') > -1: plt.ylim(-100., 100.) # Couple of useful pieces to just see what the various lines # look like over the data xFine = np.linspace(-1.2, 0.3) showByHand = False if showByHand: pTry = [-0.4, -40., -240., 40.] plt.plot(xFine, twoStraight(xFine, pTry), 'k-', lw=2, zorder=25) showFit=True if showFit: plt.plot(xFine, oneStraight(xFine, self.parsStraight), \ 'k--', lw=2, zorder=25) plt.plot(xFine, twoStraight(xFine, self.parsBroken), \ 'k-', lw=2, zorder=25)
print "==================" print "best fit slope:" pstats(mh) print "best fit normalization (pivoted) to ",ay pstats(ch) print "best fit scatter in y direction:" pstats(sh) print "==================" # # plot results: # plt.rc('font', family='sans-serif', size=16) fig=plt.figure(figsize=(6,10)) plt.subplot(211) plt.title('Metropolis') plt.plot(chain) ax = plt.subplot(212) plt.hist2d(mh,ch, bins=60, norm=LogNorm(), normed=1) plt.colorbar() plt.legend(loc='upper center') plt.ylabel('c') plt.xlabel('m') plt.show()