def plot_virtual_ase_slices(model, changes, atlas, new_figure=True, n_slices=25, xlims=None, fitter=None, denom_cutoff=5): denoms, virtualslices, fitter = get_virtual_ase_slices( model, changes, atlas, n_slices, fitter=fitter, denom_cutoff=denom_cutoff ) if new_figure: mpl.figure() virtualslices = np.ma.masked_where(np.isnan(virtualslices), virtualslices) mpl.cm.RdBu.set_bad((0.5, 0.5, 0.5)) mpl.cm.RdBu.set_over((0.5, 0.5, 0.5)) mpl.cm.RdBu.set_under((0.5, 0.5, 0.5)) xs = np.linspace(atlas.x.min(), atlas.x.max(), n_slices, endpoint=True) mpl.pcolormesh(xs, [0,1], virtualslices, cmap=mpl.cm.RdBu, vmin=-1, vmax=1) ax = mpl.gca() #ax.set_aspect(1) ax.hlines([0, 1], xs[0], xs[-1]) ax.vlines([xs[0], xs[-1]], 0, 1) if xlims: ax.set_xlim(xlims) ax.set_ylim(-0.1, 1.1) ax.set_xticks([]) ax.set_yticks([]) return denoms, virtualslices
def show_plot(X, y, n_neighbors=10, h=0.2): # Create color maps cmap_light = ListedColormap(['#FFAAAA', '#AAFFAA', '#AAAAFF','#FFAAAA', '#AAFFAA', '#AAAAFF','#FFAAAA', '#AAFFAA', '#AAAAFF','#AAAAFF']) cmap_bold = ListedColormap(['#FF0000', '#00FF00', '#0000FF','#FF0000','#FF0000','#FF0000','#FF0000','#FF0000','#FF0000','#FF0000',]) for weights in ['uniform', 'distance']: # we create an instance of Neighbours Classifier and fit the data. clf = neighbors.KNeighborsClassifier(n_neighbors, weights=weights) clf.fit(X, y) clf.n_neighbors = n_neighbors # Plot the decision boundary. For that, we will assign a color to each # point in the mesh [x_min, x_max]x[y_min, y_max]. x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1 y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1 xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h)) Z = clf.predict(np.c_[xx.ravel(), yy.ravel()]) # Put the result into a color plot Z = Z.reshape(xx.shape) plt.figure() plt.pcolormesh(xx, yy, Z, cmap=cmap_light) # Plot also the training points plt.scatter(X[:, 0], X[:, 1], c=y, cmap=cmap_bold) plt.xlim(xx.min(), xx.max()) plt.ylim(yy.min(), yy.max()) plt.title("3-Class classification (k = %i, weights = '%s')" % (n_neighbors, weights)) plt.show()
def plotSpectogramF0Segments(x, fs, w, N, H, f0, segments): """ Code for plotting the f0 contour on top of the spectrogram """ # frequency range to plot maxplotfreq = 1000.0 fontSize = 16 fig = plt.figure() ax = fig.add_subplot(111) mX, pX = stft.stftAnal(x, fs, w, N, H) #using same params as used for analysis mX = np.transpose(mX[:,:int(N*(maxplotfreq/fs))+1]) timeStamps = np.arange(mX.shape[1])*H/float(fs) binFreqs = np.arange(mX.shape[0])*fs/float(N) plt.pcolormesh(timeStamps, binFreqs, mX) plt.plot(timeStamps, f0, color = 'k', linewidth=5) for ii in range(segments.shape[0]): plt.plot(timeStamps[segments[ii,0]:segments[ii,1]], f0[segments[ii,0]:segments[ii,1]], color = '#A9E2F3', linewidth=1.5) plt.autoscale(tight=True) plt.ylabel('Frequency (Hz)', fontsize = fontSize) plt.xlabel('Time (s)', fontsize = fontSize) plt.legend(('f0','segments')) xLim = ax.get_xlim() yLim = ax.get_ylim() ax.set_aspect((xLim[1]-xLim[0])/(2.0*(yLim[1]-yLim[0]))) plt.autoscale(tight=True) plt.show()
def plot_2d(x, y, mean, variance, ei, slice_at, v1_name, v2_name): h_fig = pplt.figure(figsize=(20, 8), dpi=100) pplt.subplot(131) h_mean = pplt.pcolormesh(x, y, mean.reshape(x.shape[0], y.shape[0])) pplt.colorbar(h_mean) slice_at_list = np.squeeze(np.asarray(slice_at)).tolist() slice_at_string = str(["%.2f" % member for member in slice_at_list]) pplt.xlabel(r'$' + v1_name + '$') pplt.ylabel(r'$' + v2_name + '$') pplt.title(r'Mean, slice along $( ' + v1_name + ',' + v2_name + ')$ at ' + slice_at_string) pplt.subplot(132) h_var = pplt.pcolormesh(x, y, 2*np.sqrt(variance.reshape(x.shape[0], y.shape[0]))) pplt.colorbar(h_var) pplt.xlabel(r'$' + v1_name + '$') pplt.ylabel(r'$' + v2_name + '$') pplt.title(r'2*Stdev, slice along $( ' + v1_name + ',' + v2_name + ')$' ) pplt.subplot(133) h_ei = pplt.pcolormesh(x, y, ei.reshape(x.shape[0], y.shape[0])) pplt.colorbar(h_var) pplt.xlabel(r'$' + v1_name + '$') pplt.ylabel(r'$' + v2_name + '$') pplt.title(r'EI, slice along $( ' + v1_name + ',' + v2_name + ')$') pplt.draw() return (h_fig, h_mean, h_var, h_ei)
def plt_data(): t = [[0,1], [1,0], [1, 1], [0, 0]] t2 = [1, 1, 1, 0] X = np.array(t) Y = np.array(t2) h = .02 # step size in the mesh logreg = linear_model.LogisticRegression(C=1e5) # we create an instance of Neighbours Classifier and fit the data. logreg.fit(X, Y) # Plot the decision boundary. For that, we will assign a color to each # point in the mesh [x_min, m_max]x[y_min, y_max]. x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5 y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5 xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h)) Z = logreg.predict(np.c_[xx.ravel(), yy.ravel()]) # Put the result into a color plot Z = Z.reshape(xx.shape) plt.figure(1, figsize=(4, 3)) plt.pcolormesh(xx, yy, Z, cmap=plt.cm.Paired) # Plot also the training points plt.scatter(X[:, 0], X[:, 1], c=Y, edgecolors='k', cmap=plt.cm.Paired) plt.xlabel('Sepal length') plt.ylabel('Sepal width') plt.xlim(xx.min(), xx.max()) plt.ylim(yy.min(), yy.max()) plt.xticks(()) plt.yticks(()) plt.show()
def imshow_active_cells(grid, values, var_name=None, var_units=None, grid_units=(None, None), symmetric_cbar=False, cmap='pink'): """ .. deprecated:: 0.6 Use :meth:`imshow_active_cell_grid`, above, instead. """ data = values.view() data.shape = (grid.shape[0]-2, grid.shape[1]-2) y = np.arange(data.shape[0]) - grid.dx * .5 x = np.arange(data.shape[1]) - grid.dx * .5 if symmetric_cbar: (var_min, var_max) = (data.min(), data.max()) limit = max(abs(var_min), abs(var_max)) limits = (-limit, limit) else: limits = (None, None) plt.pcolormesh(x, y, data, vmin=limits[0], vmax=limits[1], cmap=cmap) plt.gca().set_aspect(1.) plt.autoscale(tight=True) plt.colorbar() plt.xlabel('X (%s)' % grid_units[1]) plt.ylabel('Y (%s)' % grid_units[0]) if var_name is not None: plt.title('%s (%s)' % (var_name, var_units)) plt.show()
def Pcolor(xs, ys, zs, pcolor=True, contour=False, **options): """Makes a pseudocolor plot. xs: ys: zs: pcolor: boolean, whether to make a pseudocolor plot contour: boolean, whether to make a contour plot options: keyword args passed to pyplot.pcolor and/or pyplot.contour """ Underride(options, linewidth=3, cmap=matplotlib.cm.Blues) X, Y = np.meshgrid(xs, ys) Z = zs x_formatter = matplotlib.ticker.ScalarFormatter(useOffset=False) axes = pyplot.gca() axes.xaxis.set_major_formatter(x_formatter) if pcolor: pyplot.pcolormesh(X, Y, Z, **options) if contour: cs = pyplot.contour(X, Y, Z, **options) pyplot.clabel(cs, inline=1, fontsize=10)
def fit_and_plot(cand, spd): data = cand.profile n = len(data) rms = np.std(data[(n/2):]) xs = np.linspace(0.0, 1.0, n, endpoint=False) G = gauss._compute_data(cand) print " Reduced chi-squared: %f" % (G.get_chisqr(data) / G.get_dof(n)) print " Baseline rms: %f" % rms print " %s" % G.components[0] fig1 = plt.figure(figsize=(10,10)) plt.subplots_adjust(wspace=0, hspace=0) # upper ax1 = plt.subplot2grid((3,1), (0,0), rowspan=2, colspan=1) ax1.plot(xs, data/rms, color="black", label="data") ax1.plot(xs, G.components[0].make_gaussian(n), color="red", label="best fit") # lower ax2 = plt.subplot2grid((3,1), (2,0), sharex=ax1) ax2.plot(xs, data/rms - G.components[0].make_gaussian(n), color="black", label="residuals") ax2.set_xlabel("Fraction of pulse window") plt.figure() plt.pcolormesh(xs, spd.waterfall_freq_axis(), spd.data_zerodm_dedisp, cmap=Greys) plt.xlabel("Fraction of pulse window") plt.ylabel("Frequency (MHz)") plt.xlim(0, 1) plt.ylim(spd.min_freq, spd.max_freq) plt.show()
def prettyPicture(clf, X_test, y_test): x_min = 0.0; x_max = 1.0 y_min = 0.0; y_max = 1.0 # Plot the decision boundary. For that, we will assign a color to each # point in the mesh [x_min, m_max]x[y_min, y_max]. h = .01 # step size in the mesh xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h)) Z = clf.predict(np.c_[xx.ravel(), yy.ravel()]) # Put the result into a color plot Z = Z.reshape(xx.shape) plt.xlim(xx.min(), xx.max()) plt.ylim(yy.min(), yy.max()) plt.pcolormesh(xx, yy, Z) # Plot also the test points grade_sig = [X_test[ii][0] for ii in range(0, len(X_test)) if y_test[ii] == 0] bumpy_sig = [X_test[ii][1] for ii in range(0, len(X_test)) if y_test[ii] == 0] grade_bkg = [X_test[ii][0] for ii in range(0, len(X_test)) if y_test[ii] == 1] bumpy_bkg = [X_test[ii][1] for ii in range(0, len(X_test)) if y_test[ii] == 1] plt.scatter(grade_sig, bumpy_sig, color="b", label="fast") plt.scatter(grade_bkg, bumpy_bkg, color="r", label="slow") plt.legend() plt.xlabel("bumpiness") plt.ylabel("grade") plt.savefig("test.png")
def plotmapdBtime(): pcolormesh(yoko, time*1e6, dB(S11c), vmin=-65, vmax=-30) title("Reflection (dB) vs flux \n and time (1 us pulse) at 4.46 GHz") xlabel("Flux (V)") ylabel("Time (us)") #ylim(0, 1.5) colorbar()
def test_unimodality_of_GEV(self): x0 = 1500 mu = 1000 data = np.array([x0]) ksi = np.arange(-2, 2, 0.01) sigma = np.arange(10, 8000, 10) n_ksi = len(ksi) n_sigma = len(sigma) z = np.zeros((n_ksi, n_sigma)) for i, the_ksi in enumerate(ksi): for j, the_sigma in enumerate(sigma): z[i, j] = gevfit.objective_function_stationary_high([the_sigma, mu, the_ksi], data) sigma, ksi = np.meshgrid(sigma, ksi) z = np.ma.masked_where(z == gevfit.BIG_NUM, z) z = np.ma.masked_where(z > 9, z) plt.figure() plt.pcolormesh(ksi, sigma, z) plt.colorbar() plt.xlabel('$\\xi$') plt.ylabel('$\\sigma$') plt.title('$\\mu = %.1f, x = %.1f$' % (mu, x0)) plt.show() pass
def train_plot(features, labels): y0, y1 = features[:, 2].min() * .9, features[:, 2].max() * 1.1 x0, x1 = features[:, 0].min() * .9, features[:, 0].max() * 1.1 X = np.linspace(x0, x1, 100) Y = np.linspace(y0, y1, 100) X, Y = np.meshgrid(X, Y) model = fit_model(1, features[:, (0, 2)], np.array(labels)) C = predict( np.vstack([X.ravel(), Y.ravel()]).T, model).reshape(X.shape) if COLOUR_FIGURE: cmap = ListedColormap([(1., .6, .6), (.6, 1., .6), (.6, .6, 1.)]) else: cmap = ListedColormap([(1., 1., 1.), (.2, .2, .2), (.6, .6, .6)]) plt.xlim(x0, x1) plt.ylim(y0, y1) plt.xlabel(feature_names[0]) plt.ylabel(feature_names[2]) plt.pcolormesh(X, Y, C, cmap=cmap) if COLOUR_FIGURE: cmap = ListedColormap([(1., .0, .0), (.0, 1., .0), (.0, .0, 1.)]) plt.scatter(features[:, 0], features[:, 2], c=labels, cmap=cmap) else: for lab, ma in zip(range(3), "Do^"): plt.plot(features[labels == lab, 0], features[ labels == lab, 2], ma, c=(1., 1., 1.))
def plotmaptime(): pcolormesh(yoko, time*1e6, absolute(Magcom)) title("Reflection vs flux \n and time (1 us pulse) at 4.46 GHz") xlabel("Flux (V)") ylabel("Time (us)") #ylim(0, 1.5) colorbar()
def write_potential(N=2.5, pphw=20, amplitude=1.0, sigmax=1e-1, sigmay=1e-1, L=100., W=1.0, x_R0=0.05, y_R0=0.4, loop_type='Bell', init_phase=0.0, shape='RAP', plot=True, plot_dimensions=False, direction='right', boundary_only=False, with_boundary=False, boundary_phase=0.0, theta=0.0, smearing=False, verbose=True, linearized=False): p = Potential(N=N, pphw=pphw, amplitude=amplitude, sigmax=sigmax, sigmay=sigmay, x_R0=x_R0, y_R0=y_R0, init_phase=init_phase, shape=shape, L=L, W=W, loop_type=loop_type, direction=direction, boundary_only=boundary_only, with_boundary=with_boundary, theta=theta, verbose=verbose, linearized=linearized) if not boundary_only: imag, imag_vector = p.imag, p.imag_vector real, real_vector = p.real, p.real_vector X, Y = p.X, p.Y if not boundary_only: if plot: import matplotlib.pyplot as plt if plot_dimensions: plt.figure(figsize=(L, W)) plt.pcolormesh(X, Y, imag, cmap='RdBu_r') plt.savefig("imag.png") plt.pcolormesh(X, Y, real, cmap='RdBu_r') plt.savefig("real.png") np.savetxt("potential_imag.dat", zip(xrange(len(imag_vector)), imag_vector), fmt=["%i", "%.12f"]) np.savetxt("potential_real.dat", zip(xrange(len(real_vector)), real_vector), fmt=["%i", "%.12f"]) if shape != 'science': np.savez("potential_imag_xy.npz", X=X, Y=Y, P=imag_vector, X_nodes=p.xnodes, Y_nodes=p.ynodes, sigmax=sigmax, sigmay=sigmay) if shape == 'RAP': xi_lower, xi_upper = p.WG.get_boundary(theta=theta, smearing=smearing, boundary_phase=boundary_phase) # set last element to 0 (xi_lower) or W (xi_upper) print "WARNING: end of boundary not set zero!" # xi_lower[-1] = 0.0 # xi_upper[-1] = W np.savetxt("upper.boundary", zip(xrange(p.nx), xi_upper)) np.savetxt("lower.boundary", zip(xrange(p.nx), xi_lower)) eps, delta = p.WG.get_cycle_parameters() np.savetxt("boundary.eps_delta", zip(eps, delta)) if shape == 'RAP_TQD': eps_prime, delta_prime, theta_prime = p.WG.get_quantum_driving_parameters() xi_lower, xi_upper = p.WG.get_boundary(eps=eps_prime, delta=delta_prime, theta=theta_prime, smearing=smearing) # set last element to 0 (xi_lower) or W (xi_upper) xi_lower[-1] = 0.0 xi_upper[-1] = W np.savetxt("upper.boundary", zip(xrange(p.nx), xi_upper)) np.savetxt("lower.boundary", zip(xrange(p.nx), xi_lower)) np.savetxt("boundary.eps_delta_theta", zip(eps_prime, delta_prime, theta_prime))
def visualize(self, output_file, width=2, show_charts=False): X = self.X # Create a grid of points x_min, x_max = min(X[:, 0] - width), max(X[:, 0] + width) y_min, y_max = min(X[:, 1] - width), max(X[:, 1] + width) xx,yy = np.meshgrid(np.arange(x_min, x_max, .05), np.arange(y_min, y_max, .05)) # Flatten the grid so the values match spec for self.predict xx_flat = xx.flatten() yy_flat = yy.flatten() X_topredict = np.vstack((xx_flat,yy_flat)).T # Get the class predictions Y_hat = self.predict(X_topredict) Y_hat = Y_hat.reshape((xx.shape[0], xx.shape[1])) cMap = c.ListedColormap(['r','b','g']) # Visualize them. plt.figure() plt.pcolormesh(xx,yy,Y_hat, cmap=cMap) plt.scatter(X[:, 0], X[:, 1], c=self.C, cmap=cMap) plt.savefig(output_file) if show_charts: plt.show()
def plot_2d_rabi_vs_powers(RABI_FOLDER): ''' Args: RABI_FOLDER: folder with the rabi data to use Returns: rabi_data: rabi contrast APD output 2 / APD output 1 versus tau taus: tau values in the rabi sweep powers: power values used in the 2D sweep, in dBm ''' rabi_data = [] taus = [] powers = [] for f in sorted(glob.glob('{:s}/data_subscripts/*'.format(RABI_FOLDER))): data = Script.load_data(f) if 'tau' not in data or data is None: # not a Rabi folder (e.g., find_nv instead) continue cnts = np.transpose(data['counts']) cnts1 = cnts[1] cnts0 = cnts[0] single_rabi_data = cnts1/cnts0 rabi_data.append(single_rabi_data) taus = data['tau'] power = float(f.split('_')[-1]) powers.append(power) rabi_data = np.array(rabi_data)[np.argsort(powers)] powers = np.sort(np.array(powers)) plt.pcolormesh(taus, powers, rabi_data) plt.xlabel('tau values (ns)') plt.ylabel('input power (dBm)') return rabi_data, taus, powers
def plot_eta(pT_lower_cut): properties_reco = [parse_file("/home/aashish/pythia_reco.dat", pT_lower_cut=pT_lower_cut), parse_file("/home/aashish/herwig_reco.dat", pT_lower_cut=pT_lower_cut), parse_file("/home/aashish/sherpa_reco.dat", pT_lower_cut=pT_lower_cut)] properties_truth = [parse_file("/home/aashish/pythia_truth.dat", pT_lower_cut=pT_lower_cut), parse_file("/home/aashish/herwig_truth.dat", pT_lower_cut=pT_lower_cut), parse_file("/home/aashish/sherpa_truth.dat", pT_lower_cut=pT_lower_cut)] labels = ["pythia", "herwig", "sherpa"] for prop_reco, prop_truth, label in zip(properties_reco, properties_truth, labels): x = prop_truth['hardest_eta'] y = prop_reco['hardest_eta'] H, xedges, yedges = np.histogram2d(x, y, bins=200, normed=1 ) H = np.rot90(H) H = np.flipud(H) Hmasked = np.ma.masked_where(H == 0, H) # Mask pixels with a value of zero plt.pcolormesh(xedges,yedges, Hmasked) cbar = plt.colorbar() cbar.ax.set_ylabel('Counts') plt.xlim(0, 3) plt.ylim(0, 3) plt.xlabel('Truth $\eta$', fontsize=50, labelpad=75) plt.ylabel('Reco $\eta$', fontsize=50, labelpad=75) plt.gcf().set_size_inches(30, 30, forward=1) plt.gcf().set_snap(True) plt.savefig("plots/With MC/2D/eta_" + label + ".pdf") plt.clf()
def plot_polcomp_dynspec(tims, frqs, jones): """Plot dynamic power spectra of each polarization component.""" #fig, (ax0, ax1) = plt.subplots(nrows=2) p_ch = numpy.abs(jones[:,:,0,0].squeeze())**2+numpy.abs(jones[:,:,0,1].squeeze())**2 q_ch = numpy.abs(jones[:,:,1,1].squeeze())**2+numpy.abs(jones[:,:,1,0].squeeze())**2 ftims=matplotlib.dates.date2num(tims) dynspecunit = 'flux arb.' # In dB dBunit = False if dBunit: p_ch = 10*numpy.log10(p_ch) q_ch = 10*numpy.log10(q_ch) dynspecunit += ' dB' dynspecunit += ' unit' plt.figure() plt.subplot(211) plt.pcolormesh(numpy.asarray(tims), frqs, p_ch) plt.title('p-channel') #plt.clim(0, 1.0) plt.colorbar().set_label(dynspecunit) plt.subplot(212) plt.pcolormesh(numpy.asarray(tims), frqs, q_ch) plt.title('q-channel') #plt.clim(0, 1.0) plt.xlabel('Time') plt.ylabel('Frequency') plt.colorbar().set_label(dynspecunit) plt.show()
def demo(): from time import time import matplotlib.pyplot as plt #create qx and qy evenly spaces qx = np.linspace(-.02, .02, 128) qy = np.linspace(-.02, .02, 128) qx, qy = np.meshgrid(qx, qy) #saved shape of qx r_shape = qx.shape #reshape for calculation; resize as float32 qx = qx.flatten() qy = qy.flatten() #int main pars = EllipsoidParameters(.027, 60, 180, .297e-6, 5.773e-06, 4.9, 0, 90) t = time() result = GpuEllipse(qx, qy) result.x = result.ellipsoid_fit(qx, qy, pars, b_n=35, t_n=35, a_n=1, p_n=1, sigma=3, b_w=.1, t_w=.1, a_w=.1, p_w=.1) result.x = np.reshape(result.x, r_shape) tt = time() print("Time taken: %f" % (tt - t)) plt.pcolormesh(result.x) plt.show()
def test_complete(): fig = plt.figure('Figure with a label?', figsize=(10, 6)) plt.suptitle('Can you fit any more in a figure?') # make some arbitrary data x, y = np.arange(8), np.arange(10) data = u = v = np.linspace(0, 10, 80).reshape(10, 8) v = np.sin(v * -0.6) plt.subplot(3, 3, 1) plt.plot(list(xrange(10))) plt.subplot(3, 3, 2) plt.contourf(data, hatches=['//', 'ooo']) plt.colorbar() plt.subplot(3, 3, 3) plt.pcolormesh(data) plt.subplot(3, 3, 4) plt.imshow(data) plt.subplot(3, 3, 5) plt.pcolor(data) plt.subplot(3, 3, 6) plt.streamplot(x, y, u, v) plt.subplot(3, 3, 7) plt.quiver(x, y, u, v) plt.subplot(3, 3, 8) plt.scatter(x, x**2, label='$x^2$') plt.legend(loc='upper left') plt.subplot(3, 3, 9) plt.errorbar(x, x * -0.5, xerr=0.2, yerr=0.4) ###### plotting is done, now test its pickle-ability ######### # Uncomment to debug any unpicklable objects. This is slow (~200 seconds). # recursive_pickle(fig) result_fh = BytesIO() pickle.dump(fig, result_fh, pickle.HIGHEST_PROTOCOL) plt.close('all') # make doubly sure that there are no figures left assert_equal(plt._pylab_helpers.Gcf.figs, {}) # wind back the fh and load in the figure result_fh.seek(0) fig = pickle.load(result_fh) # make sure there is now a figure manager assert_not_equal(plt._pylab_helpers.Gcf.figs, {}) assert_equal(fig.get_label(), 'Figure with a label?')
def plot_q_qhat(q, t): # Plot Potential Vorticity plt.clf() plt.subplot(2,1,1) plt.pcolormesh(xx/1e3,yy/1e3,q) plt.colorbar() plt.axes([-Lx/2e3, Lx/2e3, -Ly/2e3, Ly/2e3]) name = "PV at t = %5.2f" % (t/(3600.0*24.0)) plt.title(name) # compute power spectrum and shift ffts qe = np.vstack((q0,-np.flipud(q))) qhat = np.absolute(fftn(qe)) kx = fftshift((parms.ikx/parms.ikx[0,1]).real) ky = fftshift((parms.iky/parms.iky[1,0]).real) qhat = fftshift(qhat) Sx, Sy = int(parms.Nx/2), parms.Ny Sk = 1.5 # Plot power spectrum plt.subplot(2,1,2) #plt.pcolor(kx[Sy:Sy+20,Sx:Sx+20],ky[Sy:Sy+20,Sx:Sx+20],qhat[Sy:Sy+20,Sx:Sx+20]) plt.pcolor(kx[Sy:int(Sk*Sy),Sx:int(Sk*Sx)],ky[Sy:int(Sk*Sy),Sx:int(Sk*Sx)], qhat[Sy:int(Sk*Sy),Sx:int(Sk*Sx)]) plt.axis([0, 10, 0, 10]) plt.colorbar() name = "PS at t = %5.2f" % (t/(3600.0*24.0)) plt.title(name) plt.draw()
def test_tri_polar(self): # load data cubes = iris.load(tests.get_data_path(['NetCDF', 'ORCA2', 'votemper.nc'])) cube = cubes[0] # The netCDF file has different data types for the points and # bounds of 'depth'. This wasn't previously supported, so we # emulate that old behaviour. cube.coord('depth').bounds = cube.coord('depth').bounds.astype(np.float32) # define a latitude trajectory (put coords in a different order to the cube, just to be awkward) latitudes = range(-90, 90, 2) longitudes = [-90]*len(latitudes) sample_points = [('longitude', longitudes), ('latitude', latitudes)] # extract sampled_cube = iris.analysis.trajectory.interpolate(cube, sample_points) self.assertCML(sampled_cube, ('trajectory', 'tri_polar_latitude_slice.cml')) # turn it upside down for the visualisation plot_cube = sampled_cube[0] plot_cube = plot_cube[::-1, :] plt.clf() plt.pcolormesh(plot_cube.data, vmin=cube.data.min(), vmax=cube.data.max()) plt.colorbar() self.check_graphic() # Try to request linear interpolation. # Not allowed, as we have multi-dimensional coords. self.assertRaises(iris.exceptions.CoordinateMultiDimError, iris.analysis.trajectory.interpolate, cube, sample_points, method="linear") # Try to request unknown interpolation. self.assertRaises(ValueError, iris.analysis.trajectory.interpolate, cube, sample_points, method="linekar")
def plot_spectrogram(raw_data, nfft, fs, channel_bottom, print_frequency_graph): data_shape = raw_data.shape print("Generating spectrogram...") plt_num = 1 plt.clf() plt.figure(1) channel_data = [] for i in range(0, data_shape[1]): plt.subplot(8, 2, plt_num) f, t, Sxx = signal.spectrogram(x=raw_data[:, i], nfft=nfft, fs=fs, noverlap=127, nperseg=128, scaling='density') # returns PSD power per Hz plt.pcolormesh(t, f, Sxx) plt.xlabel('Time (sec)') plt.ylabel('Frequency (Hz)') plt.title('Channel %s' % (i + channel_bottom)) plt_num += 1 channel_data.append([f, t, Sxx]) print("\tChannel %d spectrogram generated" % i) if print_frequency_graph: plt.show() return channel_data
def Picture(clf, X_test, y_test): x_min = 200.0 x_max = 1000.0 y_min = 600.0 y_max = 2500.0 # Plot the decision boundary. For that, we will assign a color to each # point in the mesh [x_min, m_max]x[y_min, y_max]. h = 1 # step size in the mesh xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h)) Z = clf.predict(np.c_[xx.ravel(), yy.ravel()]) # Put the result into a color plot Z = Z.reshape(xx.shape) plt.xlim(xx.min(), xx.max()) plt.ylim(yy.min(), yy.max()) plt.pcolormesh(xx, yy, Z, cmap=pl.cm.seismic) # Plot also the test points x1 = [X_test[ii][0] for ii in range(0, len(X_test)) if y_test[ii] == 0] y1 = [X_test[ii][1] for ii in range(0, len(X_test)) if y_test[ii] == 0] x2 = [X_test[ii][0] for ii in range(0, len(X_test)) if y_test[ii] == 1] y2 = [X_test[ii][1] for ii in range(0, len(X_test)) if y_test[ii] == 1] x3 = [X_test[ii][0] for ii in range(0, len(X_test)) if y_test[ii] == 2] y3 = [X_test[ii][1] for ii in range(0, len(X_test)) if y_test[ii] == 2] plt.scatter(x1, y1, color="b", label="class1") plt.scatter(x2, y2, color="r", label="class2") plt.scatter(x3, y3, color="g", label="class3") plt.legend() plt.xlabel("x") plt.ylabel("y") plt.savefig("testrf.png")
def train_Quasi_linear_SVM(): from sklearn import svm clf = svm.SVC(kernel=get_KernelMatrix) X_train = np.r_[X1,X2] Y_train = np.r_[Y1,Y2] scatter(X[:,0],X[:,1],c='g') clf.fit(X_train, Y_train) y_pred = clf.predict(X_test) #scatter(X_test, y_pred) clf = svm.SVC(kernel=get_KernelMatrix) clf.fit(X, y) clf.predict(X_test1) # Plot the decision boundary. For that, we will assign a color to each # point in the mesh [x_min, m_max]x[y_min, y_max]. h = 0.05 x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1 y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1 xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h)) Z = clf.predict(np.c_[xx.ravel(), yy.ravel()]) # Put the result into a color plot Z = Z.reshape(xx.shape) plt.pcolormesh(xx, yy, Z, cmap=plt.cm.Paired) # Plot also the training points plt.scatter(X_train[:, 0], X_train[:, 1], c=Y_train) plt.title('2-Class classification using Support Vector Machine with quasi-linear kernel') plt.axis('tight') plt.legend([Y_train[0], Y_train[-1]], ['negtive sample', 'postive sample']) plt.show()
def plot_basins(f, Df, roots, xmin, xmax, ymin, ymax, numpoints=100, iters=15, colormap='brg'): '''Plot the basins of attraction of f. INPUTS: f - A function handle. Should represent a function from C to C. Df - A function handle. Should be the derivative of f. roots - An array of the zeros of f. xmin, xmax, ymin, ymax - Scalars that define the domain for the plot. numpoints - A scalar that determines the resolution of the plot. Defaults to 100. iters - Number of times to iterate Newton's method. Defaults to 15. colormap - A colormap to use in the plot. Defaults to 'brg'. ''' xreal = np.linspace(xmin, xmax, numpoints) ximag = np.linspace(ymin, ymax, numpoints) Xreal, Ximag = np.meshgrid(xreal, ximag) xold = Xreal+1j*Ximag n = 0 while n <= iters: xnew = xold - f(xold)/Df(xold) xold = xnew n += 1 converged_to = np.empty_like(xnew) for i in xrange(xnew.shape[0]): for j in xrange(xnew.shape[1]): root = np.abs(roots-xnew[i,j]).argmin() converged_to[i,j] = root plt.pcolormesh(Xreal, Ximag, converged_to, cmap=colormap)
def plotter(filename, xmin=0, xmax=300, Nx=2000, ymin=0, ymax=1, Ny=2000, sigma_x=3, sigma_y=0.01): root = '/home/cyneo/Work/Scans/Processed Data/Extracted CSV/' file1 = os.path.abspath(root + filename + '.csv') nx = linspace(xmin, xmax, Nx) ny = linspace(ymin, ymax, Ny) x, y = meshgrid(nx, ny) mastermesh = [] with open(file1, 'r', encoding='utf8') as filein: file_reader = csv.reader(filein) next(file_reader) for word, frequency, inhubness, outhubness in file_reader: # want to feed the values into the center points if mastermesh == []: mastermesh = dgaussian(x, y, float(frequency), float(outhubness), sigma_x, sigma_y) else: mastermesh += dgaussian(x, y, float(frequency), float(outhubness), sigma_x, sigma_y) for x in range(len(mastermesh)): for y in range(len(mastermesh[x])): mastermesh[x, y] = np.log(mastermesh[x, y]+1) x, y = meshgrid(nx, ny) plt.pcolormesh(x, y, mastermesh) plt.show() outfile = os.path.abspath(root + filename + ' Array') np.save(outfile, mastermesh)
def test_pcolormesh_global_with_wrap3(): nx, ny = 33, 17 xbnds = np.linspace(-1.875, 358.125, nx, endpoint=True) ybnds = np.linspace(91.25, -91.25, ny, endpoint=True) xbnds, ybnds = np.meshgrid(xbnds, ybnds) data = np.exp(np.sin(np.deg2rad(xbnds)) + np.cos(np.deg2rad(ybnds))) # this step is not necessary, but makes the plot even harder to do (i.e. # it really puts cartopy through its paces) ybnds = np.append(ybnds, ybnds[:, 1:2], axis=1) xbnds = np.append(xbnds, xbnds[:, 1:2] + 360, axis=1) data = np.ma.concatenate([data, data[:, 0:1]], axis=1) data = data[:-1, :-1] data = np.ma.masked_greater(data, 2.6) ax = plt.subplot(211, projection=ccrs.PlateCarree(-45)) c = plt.pcolormesh(xbnds, ybnds, data, transform=ccrs.PlateCarree()) assert c._wrapped_collection_fix is not None, \ 'No pcolormesh wrapping was done when it should have been.' ax.coastlines() ax.set_global() # make sure everything is visible ax = plt.subplot(212, projection=ccrs.PlateCarree(-1.87499952)) plt.pcolormesh(xbnds, ybnds, data, transform=ccrs.PlateCarree()) ax.coastlines() ax.set_global() # make sure everything is visible
def pcolorRandom(): "Makes a pcolormesh plot of randomly generated data pts." # make up some randomly distributed data npts = 100 x = uniform(-3, 3, npts) y = uniform(-3, 3, npts) z = x * N.exp(-x ** 2 - y ** 2) # define grid. xi = N.arange(-3.1, 3.1, 0.05) yi = N.arange(-3.1, 3.1, 0.05) # grid the data. zi = griddata(x, y, z, xi, yi) # contour the gridded data, plotting dots at the randomly spaced data points. plt.pcolormesh(xi, yi, zi) #CS = plt.contour(xi,yi,zi,15,linewidths=0.5,colors='k') #CS = plt.contourf(xi,yi,zi,15,cmap=plt.cm.jet) plt.colorbar() # draw colorbar # plot data points. plt.scatter(x, y, marker='o', c='b', s=5) plt.xlim(-3, 3) plt.ylim(-3, 3) plt.title('griddata test (%d points)' % npts) plt.show()
def iris_test(): # example code for LogisticRegression iris = datasets.load_iris() X = iris.data[:,:2] # first two features Y = iris.target h=.02 # step size in the mesh logreg = linear_model.LogisticRegression() logreg.fit(X,Y) x_min, x_max = X[:,0].min() - .5, X[:,0].max() + .5 y_min, y_max = X[:,1].min() - .5, X[:,1].max() + .5 xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h)) Z = logreg.predict(np.c_[xx.ravel(), yy.ravel()]) Z = Z.reshape(xx.shape) plt.figure(1, figsize=(4,3)) plt.pcolormesh(xx,yy,Z,cmap=plt.cm.Paired) plt.scatter(X[:,0],X[:,1],c=Y,edgecolors='k',cmap=plt.cm.Paired) plt.xlabel('Sepal length') plt.ylabel('Sepal width') plt.xlim(xx.min(), xx.max()) plt.ylim(yy.min(), yy.max()) plt.xticks(()) plt.yticks(()) plt.show()
x = np.array([5., 8.]) iteration = 0 verbose = 1 grad = egrad(f) H_f = jacobian(grad) color = 'black' if n == 2: # if dimension = 2 we could plot function x_line = np.arange(-10, 10, 0.05) y_line = np.arange(-10, 10, 0.05) x_grid, y_grid = np.meshgrid(x_line, y_line, sparse=True) function_values = f([x_grid, y_grid]) plt.pcolormesh(x_line, y_line, function_values, cmap=cm.get_cmap('inferno_r'), alpha=0.8) while not stop_condition(grad(x), epsilon) and iteration < 4: iteration += 1 if verbose == 1: print('-' * 40) print(f'Iteration: {iteration}') for i in range(n): print(f'Fixing coordinates exept: {i}') e = np.zeros(n) e[i] = 1
""" Do measurements by invoking test_cores() for every desired measurement (TLB type and level). Plot the result using matplotlib. """ numpy.set_printoptions(threshold=numpy.nan, linewidth=numpy.nan, precision=1) l2size=128 # test_cores('-D',3,l2size,'dtlb_load_misses.miss_causes_a_walk', cpu_uarch + '-stlb-sets.pdf', 2) l1dtlb = test_cores('-D',3,16,'dtlb_load_misses.stlb_hit', cpu_uarch + '-dtlb-sets.pdf', 1) l1itlb = test_cores('-C',3,16,'itlb_misses.stlb_hit', cpu_uarch + '-itlb-sets.pdf', 1) f, axarr = plt.subplots(nrows=1, ncols=2) f.tight_layout() matplotlib.rc('font', size=5) plt.subplot(1,2,1, adjustable='box', aspect=0.8) pcm = plt.pcolormesh(l1dtlb) plt.xticks([0,4,8,12,16]) plt.yticks([0,4,8,12,16]) plt.gca().invert_yaxis() plt.xlabel('TLB set') plt.ylabel('TLB set') plt.title('L1 dtlb') plt.subplot(1,2,2, adjustable='box', aspect=0.8) pcm = plt.pcolormesh(l1itlb) plt.gca().invert_yaxis() plt.xticks([0,4,8]) plt.yticks([0,4,8]) plt.xlabel('TLB set') plt.ylabel('TLB set') plt.title('L1 itlb')
f = open(out_filename, 'wb') pickle.dump([ results, mult_inf_range, ntemp_range, total_analysis_rmse, total_forecast_rmse, total_analysis_sprd, total_forecast_sprd ], f) f.close() if PlotTheExperiment: f = open(out_filename, 'rb') [ results, mult_inf_range, ntemp_range, total_analysis_rmse, total_forecast_rmse, total_analysis_sprd, total_forecast_sprd ] = pickle.load(f) f.close() import matplotlib.pyplot as plt plt.pcolormesh(ntemp_range, mult_inf_range, total_analysis_rmse) plt.colorbar() plt.title('Analysis Rmse') plt.xlabel('Tempering Iterantions') plt.ylabel('Multiplicative Inflation') plt.show() plt.plot(total_analysis_sprd[:, 0], total_analysis_rmse[:, 0]) plt.plot(total_analysis_sprd[:, 1], total_analysis_rmse[:, 1]) plt.plot(total_analysis_sprd[:, -1], total_analysis_rmse[:, -1]) plt.show()
a2 = nonzero(h0[a1] > 4000) b2 = nonzero(pType[a1][a2] == 2) c2 = nonzero(clutF[a1][a2][b2] > 165) zKum = ma.array(zKu, mask=zKu < 0) zKam = ma.array(zKa, mask=zKa < 0) for j1, j2 in zip(a1[0][a2][b2][c2], a1[1][a2][b2][c2]): if hIce[j1, j2] > 0: zKuL.append(zKum[j1, j2 + 22, :]) n0 += len(c2[0]) print(n0) print(h0.mean()) if h0.mean() > 4000 and cmax > 5: plt.figure() plt.subplot(211) plt.pcolormesh(zKum[:, 24, ::-1].T, cmap='jet', vmax=45) plt.xlim(i1, i2) plt.ylim(0, 120) plt.subplot(212) plt.pcolormesh(zKam[:, 12, ::-1].T, cmap='jet', vmax=35) # plt.xlim(i1, i2) plt.ylim(0, 120) plt.savefig('crossSect%2.2i.png' % ifig) # it also saves some plots plt.close('all') ifig += 1 print(fname) plt.show() zKuL = array(zKuL) zKuL[zKuL < 0] = 0 import xarray as xr
# Create color maps cmap_light = ListedColormap(['#FFAAAA', '#AAFFAA', '#AAAAFF']) cmap_bold = ListedColormap(['#FF0000', '#00FF00', '#0000FF']) for shrinkage in [None, .2]: # we create an instance of Neighbours Classifier and fit the data. clf = NearestCentroid(shrink_threshold=shrinkage) clf.fit(X, y) y_pred = clf.predict(X) print(shrinkage, np.mean(y == y_pred)) # Plot the decision boundary. For that, we will assign a color to each # point in the mesh [x_min, x_max]x[y_min, y_max]. x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1 y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1 xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h)) Z = clf.predict(np.c_[xx.ravel(), yy.ravel()]) # Put the result into a color plot Z = Z.reshape(xx.shape) plt.figure() plt.pcolormesh(xx, yy, Z, cmap=cmap_light) # Plot also the training points plt.scatter(X[:, 0], X[:, 1], c=y, cmap=cmap_bold) plt.title("3-Class classification (shrink_threshold=%r)" % shrinkage) plt.axis('tight') plt.show()
import matplotlib.pyplot as plt plt.rc('text', usetex=True) plt.rc('font', family='serif') R1, theta1, phi1, Q1 = parse_QSL_Rbinfile(filename1) Q_grid1 = np.sign(Q1) * np.log(abs(Q1)) Q_grid1[np.isinf(Q_grid1)] = np.nan R2, theta2, phi2, Q2 = parse_QSL_Rbinfile(filename2) Q_grid2 = np.sign(Q2) * np.log(abs(Q2)) Q_grid2[np.isinf(Q_grid2)] = np.nan plt.figure(figsize=(10, 10)) plt.subplot(2, 1, 1) plt.pcolormesh(phi1 * 180.0 / np.pi, theta1 * 180.0 / np.pi, Q_grid1, cmap='RdBu_r', vmin=-10, vmax=10) plt.title(r"$R=" + "{:.2f}".format(R1) + r"$ Mm", fontsize=20) plt.xlabel(r'$\phi$ [$^{\circ}$]', fontsize=20) plt.ylabel(r'$\theta$ [$^{\circ}$]', fontsize=20) plt.tick_params(axis='both', which='major', labelsize=18, direction="in", bottom=True, top=True, left=True, right=True) plt.subplot(2, 1, 2)
zKuL=array(zKuL) zXL=array(zXL) zKaL=array(zKaL) dL=array(dL) import pickle pickle.dump([zKuL,zKaL,zXL,dL],open('iphex0612.pklz','wb')) hint=h1 x1=100 x2=400 x1=230 x2=250 for i in range(8): plt.figure() x1=100+i*60 x2=100+i*60+60 plt.subplot(311) plt.pcolormesh(dL,hint,zKuL.T,vmin=0,vmax=50,cmap="jet") plt.xlim(x1,x2) plt.colorbar() plt.ylim(0,10) plt.subplot(312) plt.pcolormesh(dL,hint,(zKaL).T,vmin=0,vmax=40,cmap="jet") plt.ylim(0,10) plt.xlim(x1,x2) plt.colorbar() plt.subplot(313) plt.pcolormesh(dL,hint,zXL.T,vmin=0,vmax=50,cmap="jet") plt.ylim(0,10) plt.xlim(x1,x2) plt.colorbar()
# draw visualization of parameter effects plt.figure(figsize=(8, 6)) xx, yy = np.meshgrid(np.linspace(-3, 3, 200), np.linspace(-3, 3, 200)) for (k, (C, gamma, clf)) in enumerate(classifiers): # evaluate decision function in a grid Z = clf.decision_function(np.c_[xx.ravel(), yy.ravel()]) Z = Z.reshape(xx.shape) # visualize decision function for these parameters plt.subplot(len(C_2d_range), len(gamma_2d_range), k + 1) plt.title("gamma=10^%d, C=10^%d" % (np.log10(gamma), np.log10(C)), size='medium') # visualize parameter's effect on decision function plt.pcolormesh(xx, yy, -Z, cmap=plt.cm.RdBu) plt.scatter(X_2d[:, 0], X_2d[:, 1], c=y_2d, cmap=plt.cm.RdBu_r) plt.xticks(()) plt.yticks(()) plt.axis('tight') # plot the scores of the grid # grid_scores_ contains parameter settings and scores # We extract just the scores scores = [x[1] for x in grid.grid_scores_] scores = np.array(scores).reshape(len(C_range), len(gamma_range)) # Draw heatmap of the validation accuracy as a function of gamma and C # # The score are encoded as colors with the hot colormap which varies from dark # red to bright yellow. As the most interesting scores are all located in the
def create(path: str, name: str, header: dict, traces: List[Trace], old_style: bool = False) -> Figure: rcParams.update({'font.size': 9}) log.info('Making PID plot...') fig = plt.figure('Response plot: Log number: ' + header['logNum'] + ' ' + path, figsize=(16, 8)) # gridspec devides window into 24 horizontal, 3*10 vertical fields gs1 = GridSpec(24, 3 * 10, wspace=0.6, hspace=0.7, left=0.04, right=1., bottom=0.05, top=0.97) for i, trace in enumerate(traces): ax0 = plt.subplot(gs1[0:6, i * 10:i * 10 + 9]) plt.title(trace.name) plt.plot(trace.time, trace.gyro, label=trace.name + ' gyro') plt.plot(trace.time, trace.input, label=trace.name + ' loop input') plt.ylabel('degrees/second') ax0.get_yaxis().set_label_coords(-0.1, 0.5) plt.grid() tracelim = np.max([np.abs(trace.gyro), np.abs(trace.input)]) plt.ylim([-tracelim * 1.1, tracelim * 1.1]) plt.legend(loc=1) plt.setp(ax0.get_xticklabels(), visible=False) ax1 = plt.subplot(gs1[6:8, i * 10:i * 10 + 9], sharex=ax0) plt.hlines(header['tpa_percent'], trace.time[0], trace.time[-1], label='tpa', colors='red', alpha=0.5) plt.fill_between(trace.time, 0., trace.throttle, label='throttle', color='grey', alpha=0.2) plt.ylabel('throttle %') ax1.get_yaxis().set_label_coords(-0.1, 0.5) plt.grid() plt.xlim([trace.time[0], trace.time[-1]]) plt.ylim([0, 100]) plt.legend(loc=1) plt.xlabel('log time in s') if old_style: # response vs. time in color plot plt.setp(ax1.get_xticklabels(), visible=False) ax2 = plt.subplot(gs1[9:16, i * 10:i * 10 + 9], sharex=ax0) plt.pcolormesh(trace.avr_t, trace.time_resp, np.transpose(trace.spec_sm), vmin=0, vmax=2.) plt.ylabel('response time in s') ax2.get_yaxis().set_label_coords(-0.1, 0.5) plt.xlabel('log time in s') plt.xlim([trace.avr_t[0], trace.avr_t[-1]]) else: # response vs throttle plot. more useful. ax2 = plt.subplot(gs1[9:16, i * 10:i * 10 + 9]) plt.title(trace.name + ' response', y=0.88, color='w') plt.pcolormesh(trace.thr_response['throt_scale'], trace.time_resp, trace.thr_response['hist2d_norm'], vmin=0., vmax=2.) plt.ylabel('response time in s') ax2.get_yaxis().set_label_coords(-0.1, 0.5) plt.xlabel('throttle in %') plt.xlim([0., 100.]) cmap = plt.cm.get_cmap('Blues') cmap._init() alphas = np.abs(np.linspace(0., 0.5, cmap.N, dtype=np.float64)) cmap._lut[:-3, -1] = alphas ax3 = plt.subplot(gs1[17:, i * 10:i * 10 + 9]) plt.contourf(*trace.resp_low[2], cmap=cmap, linestyles=None, antialiased=True, levels=np.linspace(0, 1, 20, dtype=np.float64)) plt.plot(trace.time_resp, trace.resp_low[0], label=trace.name + ' step response ' + '(<' + str(int(Trace.threshold)) + ') ' + ' PID ' + header[trace.name + 'PID']) if trace.high_mask.sum() > 0: cmap = plt.cm.get_cmap('Oranges') cmap._init() alphas = np.abs(np.linspace(0., 0.5, cmap.N, dtype=np.float64)) cmap._lut[:-3, -1] = alphas plt.contourf(*trace.resp_high[2], cmap=cmap, linestyles=None, antialiased=True, levels=np.linspace(0, 1, 20, dtype=np.float64)) plt.plot(trace.time_resp, trace.resp_high[0], label=trace.name + ' step response ' + '(>' + str(int(Trace.threshold)) + ') ' + ' PID ' + header[trace.name + 'PID']) plt.xlim([-0.001, 0.501]) plt.legend(loc=1) plt.ylim([0., 2]) plt.ylabel('strength') ax3.get_yaxis().set_label_coords(-0.1, 0.5) plt.xlabel('response time in s') plt.grid() meanfreq = 1. / (traces[0].time[1] - traces[0].time[0]) ax4 = plt.subplot(gs1[12, -1]) t = BANNER + " | Betaflight: Version " + header['version'] + ' | Craftname: ' + header[ 'craftName'] + \ ' | meanFreq: ' + str(int(meanfreq)) + ' | rcRate/Expo: ' + header['rcRate'] + '/' + header[ 'rcExpo'] + '\nrcYawRate/Expo: ' + header['rcYawRate'] + '/' \ + header['rcYawExpo'] + ' | deadBand: ' + header['deadBand'] + ' | yawDeadBand: ' + \ header['yawDeadBand'] \ + ' | Throttle min/tpa/max: ' + header['minThrottle'] + '/' + header['tpa_breakpoint'] + '/' + \ header['maxThrottle'] \ + ' | dynThrPID: ' + header['dynThrottle'] + '| D-TermSP: ' + header[ 'dTermSetPoint'] + '| vbatComp: ' + header['vbatComp'] plt.text(0, 0, t, ha='left', va='center', rotation=90, color='grey', alpha=0.5, fontsize=TEXTSIZE) ax4.axis('off') log.info('Saving as image...') plt.savefig(path[:-13] + name + '_' + str(header['logNum']) + '_response.png') return fig
def _imshow_grid_values(grid, values, plot_name=None, var_name=None, var_units=None, grid_units=(None, None), symmetric_cbar=False, cmap='pink', limits=None, colorbar_label = None, allow_colorbar=True, vmin=None, vmax=None, norm=None, shrink=1., color_for_closed='black', color_for_background=None, show_elements=False, output=None): gridtypes = inspect.getmro(grid.__class__) cmap = plt.get_cmap(cmap) if color_for_closed is not None: cmap.set_bad(color=color_for_closed) else: cmap.set_bad(alpha=0.) if isinstance(grid, RasterModelGrid): if values.ndim != 2: raise ValueError('values must have ndim == 2') y = np.arange(values.shape[0] + 1) * grid.dy - grid.dy * .5 x = np.arange(values.shape[1] + 1) * grid.dx - grid.dx * .5 kwds = dict(cmap=cmap) (kwds['vmin'], kwds['vmax']) = (values.min(), values.max()) if (limits is None) and ((vmin is None) and (vmax is None)): if symmetric_cbar: (var_min, var_max) = (values.min(), values.max()) limit = max(abs(var_min), abs(var_max)) (kwds['vmin'], kwds['vmax']) = (- limit, limit) elif limits is not None: (kwds['vmin'], kwds['vmax']) = (limits[0], limits[1]) else: if vmin is not None: kwds['vmin'] = vmin if vmax is not None: kwds['vmax'] = vmax if np.isclose(grid.dx, grid.dy): if values.size == grid.number_of_nodes: myimage = plt.imshow( values.reshape(grid.shape), origin='lower', extent=(x[0], x[-1], y[0], y[-1]), **kwds) else: # this is a cell grid, and has been reshaped already... myimage = plt.imshow(values, origin='lower', extent=(x[0], x[-1], y[0], y[-1]), **kwds) myimage = plt.pcolormesh(x, y, values, **kwds) plt.gca().set_aspect(1.) plt.autoscale(tight=True) if allow_colorbar: cb = plt.colorbar(norm=norm, shrink=shrink) if colorbar_label: cb.set_label(colorbar_label) elif VoronoiDelaunayGrid in gridtypes: # This is still very much ad-hoc, and needs prettifying. # We should save the modifications needed to plot color all the way # to the diagram edge *into* the grid, for faster plotting. # (see http://stackoverflow.com/questions/20515554/... # colorize-voronoi-diagram) # (This technique is not implemented yet) from scipy.spatial import voronoi_plot_2d import matplotlib.colors as colors import matplotlib.cm as cmx cm = plt.get_cmap(cmap) if (limits is None) and ((vmin is None) and (vmax is None)): # only want to work with NOT CLOSED nodes open_nodes = grid.status_at_node != 4 if symmetric_cbar: (var_min, var_max) = (values.flat[ open_nodes].min(), values.flat[open_nodes].max()) limit = max(abs(var_min), abs(var_max)) (vmin, vmax) = (- limit, limit) else: (vmin, vmax) = (values.flat[ open_nodes].min(), values.flat[open_nodes].max()) elif limits is not None: (vmin, vmax) = (limits[0], limits[1]) else: open_nodes = grid.status_at_node != 4 if vmin is None: vmin = values.flat[open_nodes].min() if vmax is None: vmax = values.flat[open_nodes].max() cNorm = colors.Normalize(vmin, vmax) scalarMap = cmx.ScalarMappable(norm=cNorm, cmap=cm) colorVal = scalarMap.to_rgba(values) if show_elements: myimage = voronoi_plot_2d(grid.vor, show_vertices=False, show_points=False) # show_points to be supported in scipy0.18, but harmless for now mycolors = (i for i in colorVal) for order in grid.vor.point_region: region = grid.vor.regions[order] colortouse = next(mycolors) if -1 not in region: polygon = [grid.vor.vertices[i] for i in region] plt.fill(*zip(*polygon), color=colortouse) plt.gca().set_aspect(1.) # plt.autoscale(tight=True) # Tempting though it is to move the boundary outboard of the outermost # nodes (e.g., to the outermost corners), this is a bad idea, as the # outermost cells tend to have highly elongated shapes which make the # plot look stupid plt.xlim((np.min(grid.node_x), np.max(grid.node_x))) plt.ylim((np.min(grid.node_y), np.max(grid.node_y))) scalarMap.set_array(values) if allow_colorbar: cb = plt.colorbar(scalarMap, shrink=shrink) if grid_units[1] is None and grid_units[0] is None: grid_units = grid.axis_units if grid_units[1] == '-' and grid_units[0] == '-': plt.xlabel('X') plt.ylabel('Y') else: plt.xlabel('X (%s)' % grid_units[1]) plt.ylabel('Y (%s)' % grid_units[0]) else: plt.xlabel('X (%s)' % grid_units[1]) plt.ylabel('Y (%s)' % grid_units[0]) if plot_name is not None: plt.title('%s' % (plot_name)) if var_name is not None or var_units is not None: if var_name is not None: assert type(var_name) is str if var_units is not None: assert type(var_units) is str colorbar_label = var_name + ' (' + var_units + ')' else: colorbar_label = var_name else: assert type(var_units) is str colorbar_label = '(' + var_units + ')' assert type(colorbar_label) is str assert allow_colorbar cb.set_label(colorbar_label) if color_for_background is not None: plt.gca().set_axis_bgcolor(color_for_background) if output is not None: if type(output) is str: plt.savefig(output) plt.clf() elif output: plt.show()
def keo_sp_calibration(fit_path,masterdark_fname,solve_pars_fname,save_fname=None,area_rad=3, med_size=15,lat_deg=55.9305361,lon_deg=48.7444861,hei_m=91.): if save_fname==None: save_fname=solve_pars_fname.split('/')[-1][0:-11]+'.spcal' hdulist = fits.open(masterdark_fname,ignore_missing_end=True) masterdark=hdulist[0].data hdulist.close() err, az0,alt0,a,b,c,d=get_solve_pars(solve_pars_fname) M_s1c = get_scale_and_orientation_info(c,d) spath="./.temp/" if not os.path.exists(spath): os.makedirs(spath) fit_filenames=[fit_path+'/'+fn for fn in next(os.walk(fit_path))[2]] R_median=np.zeros(len(fit_filenames)) R_std=np.zeros(len(fit_filenames)) fig=plt.figure(figsize=(12.8,7.2)) fig.set_size_inches(12.8, 7.2) # ax=plt.axes(position=[0.035000000000000003+dx/2, 0.061764705882352888, 0.50624999999999998, 0.89999999999999991]) ax=plt.axes(position=[0.035000000000000003+dx/2, 0.26, 0.50624999999999998, 0.7]) plt.axis('off') ax1=plt.axes(position=[0.58205882352941185+dx, 0.71052941176470596-0.15, 0.35,0.4]) plt.grid() ax2=plt.axes(position=[0.58205882352941185+dx, 0.061764705882352888, 0.35, 0.4]) plt.grid() ax3=plt.axes(position=[0.035000000000000003+dx/2,0.04, 0.5/4, 0.7/4]) plt.grid(b=True) ax4=plt.axes(position=[0.035000000000000003+dx/2+0.19,0.04, 0.5/4, 0.7/4]) plt.grid(b=True) ax5=plt.axes(position=[0.035000000000000003+dx/2+0.38,0.04, 0.5/4, 0.7/4]) plt.grid(b=True) R_day=0 # vrange=1000 # vshift=2000 alt_min=44*np.pi/180 alt_max=62*np.pi/180 # area_rad=3 # med_size=31 XX,YY=np.meshgrid(range(2*area_rad+1),range(2*area_rad+1)) fid=open(save_fname,'w') fid.write("# Camera calibration coefficients [Rayleighs per ADC unit] for each fit file:\n") for i in range(len(fit_filenames)): # for i in range(5): # for i in range(109,120): sys.stdout.write('\r') sys.stdout.write("Processing frame "+str(i+1)+"/"+str(len(fit_filenames))) sys.stdout.flush() fit_fname=fit_filenames[i] hdulist = fits.open(fit_fname,ignore_missing_end=True) img=hdulist[0].data.astype('float') img0=np.copy(img) img=img-masterdark.astype('float') img_medfilt=img - ss.medfilt(img,kernel_size=med_size) # np.save('img.npy',img) hdulist.close() med_img=np.median(img) max_img0=np.max(img0) # print(max_img0) keo_site=EarthLocation(lat=lat_deg*u.deg, lon=lon_deg*u.deg, height=hei_m*u.m) date_obs=keo_get_date_obs(fit_fname) png_prefix=spath+"frame_keo_"+str(date_obs.year)[2::]+"{0:0>2}".format(date_obs.month)+"{0:0>2}".format(date_obs.day)+"_" BS_coord=SkyCoord(RA, DEC, frame='icrs', unit='rad'); altaz=BS_coord.transform_to(AltAz(obstime=date_obs, location=keo_site,temperature=20*u.deg_C,pressure=1013*u.hPa, relative_humidity=0.5,obswl=630.0*u.nm)) AZ=altaz.az.rad ALT=altaz.alt.rad X,Y = arc_hor2pix(AZ,ALT,az0,alt0,c,d) # Catalog filtration filt_mask=np.zeros(len(NUM),dtype=bool) for j in range(len(NUM)): if ALT[j]>=alt_min and ALT[j]<=alt_max and X[j]>=10 and Y[j]>=10 and X[j]<=img.shape[1]-10 and Y[j]<=img.shape[0]-10: filt_mask[j]=True NUM_filt=NUM[filt_mask] BS_ID_filt=BS_ID[filt_mask] RA_filt=RA[filt_mask] DEC_filt=DEC[filt_mask] MAG_filt=MAG[filt_mask] FLUX_filt=FLUX[filt_mask] SP_type_filt=[SP_type[j] for j in range(len(SP_type)) if filt_mask[j]==True] ALT_filt=ALT[filt_mask] AZ_filt=AZ[filt_mask] X_filt=X[filt_mask] Y_filt=Y[filt_mask] star_pixels=np.zeros(len(NUM_filt),dtype=int) star_adc=np.zeros(len(NUM_filt)) AREA=np.zeros((2*area_rad+1,2*area_rad+1,len(NUM_filt))) AREA0=np.zeros((2*area_rad+1,2*area_rad+1,len(NUM_filt))) for j in range(len(NUM_filt)): sum_temp=0 num=0 AREA[:,:,j]=np.copy(img_medfilt[int(Y_filt[j])-area_rad:int(Y_filt[j])+area_rad+1, int(X_filt[j])-area_rad:int(X_filt[j])+area_rad+1]) AREA0[:,:,j]=np.copy(img0[int(Y_filt[j])-area_rad:int(Y_filt[j])+area_rad+1, int(X_filt[j])-area_rad:int(X_filt[j])+area_rad+1]) arg_max=np.argmax(AREA[:,:,j]) # print("max=", np.max(AREA[:,:,j])) x0=XX.flat[arg_max] y0=YY.flat[arg_max] AREA[:,:,j]=np.copy(img_medfilt[int(Y_filt[j])-area_rad+y0-area_rad:int(Y_filt[j])+y0+1, int(X_filt[j])-area_rad+x0-area_rad:int(X_filt[j])+x0+1]) AREA0[:,:,j]=np.copy(img0[int(Y_filt[j])-area_rad+y0-area_rad:int(Y_filt[j])+y0+1, int(X_filt[j])-area_rad+x0-area_rad:int(X_filt[j])+x0+1]) Rast=np.sqrt((XX-area_rad)**2+(YY-area_rad)**2) # print(Rast) area=np.copy(AREA[:,:,j]) for k in range((2*area_rad+1)**2): if Rast.flat[k]<=area_rad: num+=1 sum_temp+=AREA[:,:,j].flat[k] star_pixels[j]=num star_adc[j]=sum_temp # print(star_pixels[j],star_adc[j]) # print(AREA[:,:,j]) # print(" ") # Catalog filtration 2 filt_mask=np.zeros(len(NUM_filt),dtype=bool) for j in range(len(NUM_filt)): if np.max(AREA0[:,:,j])<0.9*max_img0: if np.max(AREA[:,:,j])>1000: filt_mask[j]=True AREA_filt2=np.copy(AREA[:,:,filt_mask]) AREA0_filt2=np.copy(AREA0[:,:,filt_mask]) NUM_filt2=NUM_filt[filt_mask] BS_ID_filt2=BS_ID_filt[filt_mask] RA_filt2=RA_filt[filt_mask] DEC_filt2=DEC_filt[filt_mask] MAG_filt2=MAG_filt[filt_mask] FLUX_filt2=FLUX_filt[filt_mask] SP_type_filt2=[SP_type_filt[j] for j in range(len(SP_type_filt)) if filt_mask[j]==True] X_filt2=X_filt[filt_mask] Y_filt2=Y_filt[filt_mask] ALT_filt2=ALT_filt[filt_mask] AZ_filt2=AZ_filt[filt_mask] star_pixels_filt2=star_pixels[filt_mask] star_adc_filt2=star_adc[filt_mask] R=np.zeros(len(NUM_filt2)) for j in range(len(NUM_filt2)): sol_angle=tan_get_pixel_solid_angle(M_s1c,np.pi/2-ALT_filt2[j]) br=get_brightness_in_Rayleighs(20,sol_angle,1,FLUX_filt2[j]) sa=star_adc_filt2[j] R[j]=br/sa # print('br[R]=', br, "; sa[ADC.u]=",sa,"; R=",R[j]) x_bord=np.arange(2*area_rad+1,dtype=float) y1_bord=np.sqrt(area_rad**2-(x_bord-area_rad)**2)+area_rad+0.5 y2_bord=-np.sqrt(area_rad**2-(x_bord-area_rad)**2)+area_rad+0.5 if len(NUM_filt2)>0: sort_ord=np.argsort(star_pixels_filt2) plt.sca(ax3) idd=0 area1=AREA_filt2[:,:,sort_ord[idd]] area1_max=np.max(AREA0_filt2[:,:,sort_ord[idd]]) area1_id=BS_ID_filt2[sort_ord[idd]] plt.pcolormesh(area1, cmap="seismic",vmin=-1000, vmax=1000) plt.plot(x_bord+0.5,y1_bord,'k-',lw=2) plt.plot(x_bord+0.5,y2_bord,'k-',lw=2) plt.ylim(area_rad*2+1,0) plt.xlim(0,area_rad*2+1) plt.title(str(area1_id),loc='left',fontsize='smaller') plt.title(str(int(star_adc_filt2[sort_ord[idd]])),loc='right',fontsize='smaller') plt.title(str(int(R[sort_ord[idd]]*1000)/1000),fontsize='smaller') plt.ylabel(str(int(R[sort_ord[idd]]*star_adc_filt2[sort_ord[idd]]))) if len(NUM_filt2)>1: plt.sca(ax4) idd=1 area2=AREA_filt2[:,:,sort_ord[idd]] area2_max=np.max(AREA0_filt2[:,:,sort_ord[idd]]) area2_id=BS_ID_filt2[sort_ord[idd]] plt.pcolormesh(area2, cmap="seismic",vmin=-1000, vmax=1000) plt.plot(x_bord+0.5,y1_bord,'k-',lw=2) plt.plot(x_bord+0.5,y2_bord,'k-',lw=2) plt.ylim(area_rad*2+1,0) plt.xlim(0,area_rad*2+1) plt.title(str(area2_id),loc='left',fontsize='smaller') plt.title(str(int(star_adc_filt2[sort_ord[idd]])),loc='right',fontsize='smaller') plt.title(str(int(R[sort_ord[idd]]*1000)/1000),fontsize='smaller') plt.ylabel(str(int(R[sort_ord[idd]]*star_adc_filt2[sort_ord[idd]]))) if len(NUM_filt2)>2: plt.sca(ax5) idd=2 area3=AREA_filt2[:,:,sort_ord[idd]] area3_max=np.max(AREA0_filt2[:,:,sort_ord[idd]]) area3_id=BS_ID_filt2[sort_ord[idd]] plt.pcolormesh(area3, cmap="seismic",vmin=-1000, vmax=1000) plt.plot(x_bord+0.5,y1_bord,'k-',lw=2) plt.plot(x_bord+0.5,y2_bord,'k-',lw=2) plt.ylim(area_rad*2+1,0) plt.xlim(0,area_rad*2+1) plt.title(str(area3_id),loc='left',fontsize='smaller') plt.title(str(int(star_adc_filt2[sort_ord[idd]])),loc='right',fontsize='smaller') plt.title(str(int(R[sort_ord[idd]]*1000)/1000),fontsize='smaller') plt.ylabel(str(int(R[sort_ord[idd]]*star_adc_filt2[sort_ord[idd]]))) # print(len(R),R) if len(R)>0: R_median[i]=np.median(R) temp=(R-R_median[i])**2 R_std[i]=np.sqrt(np.median(temp)) # print(R_median[i]) plt.sca(ax1) plt.plot([0, 50000], [R_median[i], R_median[i]], c='r', lw=2) plt.scatter(R*star_adc_filt2,R,s=np.pi*(star_adc_filt2/12000*7)**2) # print(R[0]*star_adc_filt2[0]) # print(R[0]*star_adc_filt2[0]*star_pixels_filt2[0]) for j in range(len(X_filt2)): plt.text(R[j]*star_adc_filt2[j],R[j],str(BS_ID_filt2[j])+"_"+str(star_pixels_filt2[j])) plt.ylabel('Calibration coef. [R/ADCu]') plt.xlabel('Star summ brightness [R]') plt.title(date_obs, loc='left') plt.title(R_median[i], loc='right') ax1.set_xlim((0, 30000)) ax1.set_ylim((0, 1)) plt.grid(b=True) plt.sca(ax2) plt.xlim([0,len(fit_filenames)-1]) plt.ylim([0,1]) plt.plot(i,R_median[i],"r.") plt.grid(b=True) plt.ylabel('Calibration coef. [R/ADCu]') plt.xlabel('frame number') if i==len(fit_filenames)-1: R_day=np.median(R_median[np.where(R_median>0)]) plt.plot([0, 5000], [R_day, R_day], c='b', lw=2) plt.title(R_day, loc='right') plt.sca(ax) plt.pcolormesh(img, cmap="gray", vmin=np.median(img)-300, vmax=np.median(img)+300) plt.axis('equal') plt.plot(X,Y,marker="o", lw=0.,mew=mew,mec="b", mfc='none',ms=ms) plt.plot(X_filt,Y_filt,marker="o", lw=0.,mew=mew,mec="g", mfc='none',ms=ms) plt.plot(X_filt2,Y_filt2,marker="o", lw=0.,mew=mew,mec="r", mfc='none',ms=ms) for j in range(len(X_filt2)): plt.text(X_filt2[j],Y_filt2[j],str(BS_ID_filt2[j])+"_" + "{0:4.2f}".format(R[j]), color='w') ax.set_xlim((0,img.shape[1])) ax.set_ylim((img.shape[0],0)) plt.title(fit_fname.split('/')[-1] + " " + "{0:0>2}".format(date_obs.hour) + ":" + "{0:0>2}".format(date_obs.minute) + ":" + "{0:0>2}".format(date_obs.second)) # plt.show() plt.axis('off') png_fname=png_prefix+"{0:0>4}".format(i+1)+".png" # print(png_fname) plt.savefig(png_fname) ax.clear() ax1.clear() ax3.clear() ax4.clear() ax5.clear() fid.write(fit_fname.split('/')[-1] + " " + str(R_median[i])+ " " + str(R_std[i]) + "\n") plt.close() sys.stdout.write('\n') sys.stdout.flush() fid.close() return png_prefix, len(fit_filenames), R_median
lost = 0 nothingness = 0 rewards = [] fig = plt.figure(figsize=(20, 20)) for ep in range(TOT_EPISODES): anim = [] win = 0 tot_reward = 0 mondo = World(WORLD_DIM, bilbo=bilbo, obstacle=False, random_spawn=True) #do deep Q-stuff game_ended = False epoch = 0 current_state = bilbo.get_state() env = mondo.create_env(d) anim.append((plt.pcolormesh(env, cmap='CMRmap'), )) while not game_ended and epoch < MAX_EPOCH: #the near it gets to the dragon the more random the movement epoch += 1 mondo.move_dragon() action = bilbo.get_action(0, possible_moves) bilbo.move(inverse_possible_moves[action])() new_state = bilbo.get_state() reward = bilbo.reward(current_state, new_state) if not reward in [-2, 1]: tot_reward += reward game_ended = bilbo.game_ended() current_state = new_state if reward == TREASURE_REWARD: win += 1
def visualize_feats(sound, features='fbank', win_size_ms = 20, \ win_shift_ms = 10,num_filters=40,num_mfcc=40, samplerate=None,\ save_pic=False, name4pic=None): '''Visualize feature extraction depending on set parameters Parameters ---------- sound : str or numpy.ndarray If str, wavfile (must be compatible with scipy.io.wavfile). Otherwise the samples of the sound data. Note: in the latter case, `samplerate` must be declared. features : str Either 'mfcc' or 'fbank' features. MFCC: mel frequency cepstral coefficients; FBANK: mel-log filterbank energies (default 'fbank') win_size_ms : int or float Window length in milliseconds for Fourier transform to be applied (default 20) win_shift_ms : int or float Window overlap in milliseconds; default set at 50% window size (default 10) num_filters : int Number of mel-filters to be used when applying mel-scale. For 'fbank' features, 20-128 are common, with 40 being very common. (default 40) num_mfcc : int Number of mel frequency cepstral coefficients. First coefficient pertains to loudness; 2-13 frequencies relevant for speech; 13-40 for acoustic environment analysis or non-linguistic information. Note: it is not possible to choose only 2-13 or 13-40; if `num_mfcc` is set to 40, all 40 coefficients will be included. (default 40). samplerate : int, optional The sample rate of the sound data or the desired sample rate of the wavfile to be loaded. (default None) ''' data, sr = load_sound(sound, samplerate=samplerate) win_samples = int(win_size_ms * sr // 1000) if 'fbank' in features: feats = logfbank(data, samplerate=sr, winlen=win_size_ms * 0.001, winstep=win_shift_ms * 0.001, nfilt=num_filters, nfft=win_samples) axis_feature_label = 'Mel Filters' elif 'mfcc' in features: feats = mfcc(data, samplerate=sr, winlen=win_size_ms * 0.001, winstep=win_shift_ms * 0.001, nfilt=num_filters, numcep=num_mfcc, nfft=win_samples) axis_feature_label = 'Mel Freq Cepstral Coefficients' feats = feats.T plt.clf() plt.pcolormesh(feats) plt.xlabel('Frames (each {} ms)'.format(win_size_ms)) plt.ylabel('Num {}'.format(axis_feature_label)) plt.title('{} Features'.format(features.upper())) if save_pic: outputname = name4pic or 'visualize{}feats'.format(features.upper()) plt.savefig('{}.png'.format(outputname)) else: plt.show()
def fitting(Z, n, remain3D=False, remain2D=False, barchart=False, interferogram=False, removepiston=True): """ ------------------------------------------------ fitting(Z,n) Fitting an aberration to several orthonormal Zernike polynomials. Return: n-th Zernike coefficients for a fitting surface aberration Zernike coefficients barchart Remaining aberration Fiting surface plot Input: Z: A surface or aberration matrix measure from inteferometer or something else. n: How many order of Zernike Polynomials you want to fit reamin(default==Flase): show the surface after remove fitting aberrations. removepiston: if remove piston, default = True ------------------------------------------------ """ fitlist = [] l = len(Z) x2 = __np__.linspace(-1, 1, l) y2 = __np__.linspace(-1, 1, l) [X2, Y2] = __np__.meshgrid(x2, y2) r = __np__.sqrt(X2**2 + Y2**2) u = __np__.arctan2(Y2, X2) for i in range(n): C = [0] * i + [1] + [0] * (37 - i - 1) ZF = __zernikepolar__(C, r, u) for i in range(l): for j in range(l): if x2[i]**2 + y2[j]**2 > 1: ZF[i][j] = 0 a = sum(sum(Z * ZF)) * 2 * 2 / l / l / __np__.pi fitlist.append(round(a, 3)) l1 = len(fitlist) fitlist = fitlist + [0] * (37 - l1) Z_new = Z - __zernikepolar__(fitlist, r, u) for i in range(l): for j in range(l): if x2[i]**2 + y2[j]**2 > 1: Z_new[i][j] = 0 #plot bar chart of zernike if barchart == True: fitlist1 = fitlist[0:n] index = __np__.arange(n) fig = __plt__.figure(figsize=(9, 6), dpi=80) xticklist = [] width = 0.6 for i in index: xticklist.append('Z' + str(i + 1)) barfigure = __plt__.bar(index, fitlist1, width, color='#2E9AFE', edgecolor='#2E9AFE') __plt__.xticks(index + width / 2, xticklist) __plt__.xlabel('Zernike Polynomials', fontsize=18) __plt__.ylabel('Coefficient', fontsize=18) __plt__.title('Fitting Zernike Polynomials Coefficient', fontsize=18) __plt__.show() else: pass if remain3D == True: fig = __plt__.figure(figsize=(12, 8), dpi=80) ax = fig.gca(projection='3d') surf = ax.plot_surface(X2, Y2, Z_new, rstride=1, cstride=1, cmap=__cm__.RdYlGn, linewidth=0, antialiased=False, alpha=0.6) v = max(abs(Z.max()), abs(Z.min())) ax.set_zlim(-v, v) ax.zaxis.set_major_locator(__LinearLocator__(10)) ax.zaxis.set_major_formatter(__FormatStrFormatter__('%.02f')) cset = ax.contourf(X2, Y2, Z_new, zdir='z', offset=-v, cmap=__cm__.RdYlGn) fig.colorbar(surf, shrink=1, aspect=30) __plt__.title('Remaining Aberration', fontsize=18) p2v = round(__tools__.peak2valley(Z_new), 5) rms1 = round(__tools__.rms(Z_new), 5) label_new = "P-V: " + str(p2v) + "\n" + "RMS: " + str(rms1) ax.text2D(0.02, 0.1, label_new, transform=ax.transAxes) __plt__.show() else: pass if remain2D == True: fig = __plt__.figure(figsize=(9, 6), dpi=80) ax = fig.gca() im = __plt__.pcolormesh(X2, Y2, Z_new, cmap=__cm__.RdYlGn) __plt__.colorbar() __plt__.title('Remaining Aberration', fontsize=18) ax.set_aspect('equal', 'datalim') __plt__.show() else: pass if interferogram == True: zernike_coefficient = Coefficient(fitlist) __interferometer__.twyman_green(zernike_coefficient) else: pass if removepiston == True: fitlist[0] = 0 else: pass C = Coefficient(fitlist) #output zernike Coefficient class __tools__.zernikeprint(fitlist) return fitlist, C
def visualize_pred(self, image_in, tfrecord_file, predictions_list): # Pipeline of dataset and iterator dataset = tf.data.TFRecordDataset([tfrecord_file]) dataset = dataset.map(parse) iterator = dataset.make_one_shot_iterator() next_image_data = iterator.get_next() num_of_stixels = len(predictions_list) print('Number of stixels to be proceesed {}'.format(num_of_stixels)) # Go through the TFRecord and reconstruct the images + predictions # Init new image new_im = Image.new('RGB', (self.image_width, self.H)) grid = np.zeros((self.grid_y_width, self.grid_x_width)) x_offset = 0 first_time = True fig, ax = plt.subplots() # Go through all the stixels in the tfrecord file #for i in range(num_of_stixels): for i in range(num_of_stixels): image_data = self.sess.run(next_image_data) image = image_data[0]['image'] im = Image.fromarray(np.uint8(image)) frame_id = image_data[1] prediction = predictions_list[i]['classes'] prediction_softmax = predictions_list[i]['probabilities'] ##################################################################################### ## Collect all image predictions into a new array tp be filtered by CRF++/CRFSuite ## ##################################################################################### #label = image_data[1] #frame_id = image_data[2] #frame_name = image_data[3] # Collect and visualize stixels new_im.paste(im, (frame_id * 5, 0)) x_offset += 5 if self.debug_image: plt.plot(int(params.image_width / 2) + 5 * (frame_id), prediction * self.prediction_to_pixels, marker='o', markersize=4, color="red") # visualize probabilities grid[:,frame_id] = prediction_softmax plt.draw() # Use CRF to find the best path from code.crf import viterbi best_path = viterbi(grid.T, N, T, W_trans) # Plot the CRF border line best_path_points = [] for index, path in enumerate(best_path): best_path_points.append([int(params.image_width / 2) + index * 5, path * 5 + self.y_spacing]) plt.plot(np.array(best_path_points)[:,0], np.array(best_path_points)[:,1], color="blue", linewidth=self.plot_border_width) # If labeles exist and not in debug mode, plot the labels annotation_in = image_in.replace('.jpg', '.csv') if os.path.exists(annotation_in): del_y = self.image_size[1] - self.H #del_y = self.image_size[1] - 370 # Init from the CSV file with open(annotation_in) as csv_file: csv_reader = csv.reader(csv_file, delimiter=',') label_coords = [] for index, row in enumerate(csv_reader): new_tuple = tuple(row) x_coord = int(new_tuple[0]) y_coord = max(int(new_tuple[1]) - del_y, 0) plt.plot(x_coord, y_coord, marker='o', markersize=5, color="red") label_coords.append([x_coord, y_coord]) # Compute the prediction accuracy # If not in debug mode, display the labels if not self.debug_image: plt.plot(np.array(label_coords)[:, 0], np.array(label_coords)[:, 1], color="red", linewidth=1.0) if self.debug_image: #In debug mode plot the softmax probabilities grid = np.ma.masked_array(grid, grid < .0001) plt.pcolormesh(self.X, self.Y, grid, norm=colors.LogNorm(), alpha = 0.75) plt.imshow(new_im, cmap='gray', alpha=1.0, interpolation='none') name = ' {} N{}_T{}_Tr{}.jpg'.format(self.model_name, N, T, W_trans) if self.debug_image: name.replace('.jpg',' debug.jpg') name = ' {} N{}_T{}_Tr{} debug.jpg'.format(self.model_name, N, T, W_trans) print('replacing name to indicate debug !!!!!!') print(name) image_out_name = os.path.basename(image_in) image_out_name = image_out_name.replace('.jpg', name) image_out_name = os.path.basename(image_out_name) image_file_name = os.path.join(self.out_folder, image_out_name) plt.savefig(image_file_name, format='jpg') print('saving fig to ', image_file_name) if self.show_images: plt.show() plt.close()
Quasi_linear_kernel = partial(get_Quasi_linear_Kernel.get_KernelMatrix,RMat=RMat) clf = svm.SVC(kernel=Quasi_linear_kernel) clf.fit(X, Y) #========================== plot data face ================================ plot_step = 0.01 x_min = X[:, 0].min() x_max = X[:, 0].max() y_min = X[:, 1].min() y_max = X[:, 1].max() xx, yy = np.meshgrid(np.arange(x_min, x_max, plot_step), np.arange(y_min, y_max, plot_step)) Z = myTree.predict(np.c_[xx.ravel(), yy.ravel()]) Z = Z.reshape(xx.shape) plt.pcolormesh(xx,yy,Z, cmap=plt.cm.Paired) plt.imshow(Z, interpolation='nearest', cmap=plt.cm.PuOr_r) plt.contour(xx, yy, Z, colors=['k', 'k', 'k'], linestyles=['--', '-', '--'], levels=[-.5, 0, .5],linewidths=2) Z_svm = clf.predict(np.c_[xx.ravel(), yy.ravel()]) Z_svm = Z_svm.reshape(xx.shape) contours = plt.contourf(xx,yy,Z_svm, cmap=plt.cm.Paired) # another way to pass the kernel matrix K_train = Quasi_linear_kernel(X,X) K_test = Quasi_linear_kernel(np.c_[xx.ravel(), yy.ravel()],X) clf = svm.SVC(kernel='precomputed' , C=100) clf.fit(K_train, Y ) Z = clf.predict(K_test) Z = Z.reshape(xx.shape)
#databaru = (np.max(data_np)) #print(databaru) #data = np.array(data_int, dtype='b') #f, t, Sxx = signal.spectrogram(yf, RATE, nperseg=64) f, t, Sxx = signal.spectrogram(data_np, RATE, nperseg=64, nfft=256, noverlap=60) #f, t, Sxx = signal.spectrogram(yf, RATE, noverlap=250) #f, t, Sxx = signal.spectrogram(data_np, fs=CHUNK) dBS = 10 * np.log10(Sxx) #convert db #plt.pcolormesh(t, f, dBS) plt.pcolormesh(t, f, dBS, cmap='nipy_spectral') #plt.pcolormesh(t, f, dBS) #plt.show() #Accent, Accent_r, Blues, Blues_r, BrBG, BrBG_r, BuGn, BuGn_r, BuPu, BuPu_r, CMRmap, CMRmap_r, Dark2, Dark2_r, GnBu, GnBu_r, Greens, Greens_r, Greys, Greys_r, #OrRd, OrRd_r, Oranges, Oranges_r, PRGn, PRGn_r, Paired, Paired_r, Pastel1, Pastel1_r, Pastel2, Pastel2_r, PiYG, PiYG_r, PuBu, PuBuGn, PuBuGn_r, PuBu_r, PuOr, # PuOr_r, PuRd, PuRd_r, Purples, Purples_r, RdBu, RdBu_r, RdGy, RdGy_r, RdPu, RdPu_r, RdYlBu, RdYlBu_r, RdYlGn, RdYlGn_r, Reds, Reds_r, # Set1, Set1_r, Set2, Set2_r, Set3, Set3_r, Spectral, Spectral_r, Wistia, Wistia_r, YlGn, YlGnBu, YlGnBu_r, YlGn_r, YlOrBr, YlOrBr_r, YlOrRd, YlOrRd_r, afmhot, #afmhot_r, autumn, autumn_r, binary, binary_r, bone, bone_r, brg, brg_r, bwr, bwr_r, cividis, cividis_r, cool, cool_r, coolwarm, coolwarm_r, copper, copper_r, # cubehelix, cubehelix_r, flag, flag_r, gist_earth, gist_earth_r, gist_gray, gist_gray_r, gist_heat, gist_heat_r, gist_ncar, gist_ncar_r, gist_rainbow, gist_rainbow_r, # gist_stern, gist_stern_r, gist_yarg, gist_yarg_r, gnuplot, gnuplot2, gnuplot2_r, gnuplot_r, gray, gray_r, hot, hot_r, hsv, hsv_r, inferno, inferno_r, jet, jet_r, # magma, magma_r, nipy_spectral, nipy_spectral_r, ocean, ocean_r, pink, pink_r, plasma, plasma_r, prism, prism_r, rainbow, rainbow_r, seismic, seismic_r, spring, spring_r, # summer, summer_r, tab10, tab10_r, tab20, tab20_r, tab20b, tab20b_r, tab20c, tab20c_r, terrain, terrain_r, viridis, viridis_r, winter, winter_r widths = np.arange(1, 50) cwtmatr = signal.cwt(data_np, signal.ricker, widths) #scales = mlpy.wavelet.autoscales(N=len(data),dt=1,dj=0.05,wf='morlet',p=omega0) #spec = mlpy.wavelet.cwt(data[:,1],dt=1,scales=scales,wf='morlet',p=omega0)
import numpy as np import matplotlib.pyplot as plt from matplotlib.backends.backend_pdf import PdfPages import matplotlib x = np.arange(0.01, 10, 0.05) y = np.arange(0.01, 10, 0.05) X, Y = np.meshgrid(x, y) m = np.array([1.0, 2.0]) Z = X + Y - m[0] - m[1] - X * np.log(X/m[0]) - Y * np.log(Y/m[1]) fig = plt.figure() ax = plt.axes() plt.pcolormesh(X, Y, Z, cmap='magma') pp=plt.colorbar (orientation="vertical") plt.rcParams['font.size'] = 16 plt.rcParams['xtick.labelsize'] = 16 plt.rcParams['ytick.labelsize'] = 16 matplotlib.rcParams['ps.useafm'] = True matplotlib.rcParams['pdf.use14corefonts'] = True cont=plt.contour(X,Y,Z,8,vmin=-1,vmax=1, colors=['black']) cont.clabel(fmt='%1.1f', fontsize=16) plt.plot(1.0,2.0,marker='.',markersize=16) plt.xlabel(r'$x_1$', fontsize=16) plt.ylabel(r'$x_2$', fontsize=16) plt.tick_params(which='major', labelsize=16) plt.gca().set_aspect('equal') ppdf = PdfPages('information_entropy.pdf')
interp.data[~I_ann] = np.nan a = np.reshape(interp.qx_data, (sans.nq, sans.nq)) b = np.reshape(interp.qy_data, (sans.nq, sans.nq)) c = np.reshape(interp.data, (sans.nq, sans.nq)) # vmax = np.nanmax(c) # vmin = np.nanmin(c) vmax = np.nanmax(sans.expData.data) vmin = np.nanmin(sans.expData.data) print(vmax) # d = np.reshape(I_ann, (50,50)) # ax = plt.subplot() plt.figure(figsize=[5, 5], dpi=500) # plt.plot(np.array([0, 0.06]), [0, 0.06]) plt.pcolormesh(a, b, c, cmap=parula, vmin=2, vmax=vmax, norm=mcolors.LogNorm()) # plt.colorbar(shrink=0.7, ticks=[20, 25, 30, 35]) plt.xlim(-0.055, 0.055) plt.ylim(-0.055, 0.055) plt.xticks([-0.05, -0.025, 0, 0.025, 0.05], [-50, -25, 0, 25, 50]) plt.yticks([-0.05, -0.025, 0, 0.025, 0.05], [-50, -25, 0, 25, 50]) fontsize = '16' plt.xlabel('q ' + r'/ $\bf{10^{-3} \: \: \AA^{-1}}$', fontweight='bold', fontsize=fontsize) plt.ylabel('q ' + r'/ $\bf{10^{-3} \: \: \AA^{-1}}$', fontweight='bold', fontsize=fontsize) plt.rc('figure', frameon=False) plt.rc('axes.spines', top=False)
def parseFQ(inf): print 'reading ' + inf + '...' if inf[-3:] == '.gz': print 'detected gzip suffix...' f = gzip.open(inf, 'r') else: f = open(inf, 'r') IS_SAM = False if inf[-4:] == '.sam': print 'detected sam input...' IS_SAM = True rRead = 0 actual_readlen = 0 qDict = {} while True: if IS_SAM: data4 = f.readline() if not len(data4): break try: data4 = data4.split('\t')[10] except IndexError: break # need to add some input checking here? Yup, probably. else: data1 = f.readline() data2 = f.readline() data3 = f.readline() data4 = f.readline() if not all([data1, data2, data3, data4]): break if actual_readlen == 0: if inf[-3:] != '.gz' and not IS_SAM: totalSize = os.path.getsize(inf) entrySize = sum([len(n) for n in [data1, data2, data3, data4]]) print 'estimated number of reads in file:', int( float(totalSize) / entrySize) actual_readlen = len(data4) - 1 print 'assuming read length is uniform...' print 'detected read length (from first read found):', actual_readlen priorQ = np.zeros([actual_readlen, RQ]) totalQ = [None] + [ np.zeros([RQ, RQ]) for n in xrange(actual_readlen - 1) ] # sanity-check readlengths if len(data4) - 1 != actual_readlen: print 'skipping read with unexpected length...' continue for i in range(len(data4) - 1): q = ord(data4[i]) - offQ qDict[q] = True if i == 0: priorQ[i][q] += 1 else: totalQ[i][prevQ, q] += 1 priorQ[i][q] += 1 prevQ = q rRead += 1 if rRead % PRINT_EVERY == 0: print rRead if MAX_READS > 0 and rRead >= MAX_READS: break f.close() # some sanity checking again... QRANGE = [min(qDict.keys()), max(qDict.keys())] if QRANGE[0] < 0: print '\nError: Read in Q-scores below 0\n' exit(1) if QRANGE[1] > RQ: print '\nError: Read in Q-scores above specified maximum:', QRANGE[ 1], '>', RQ, '\n' exit(1) print 'computing probabilities...' probQ = [None] + [[[0. for m in xrange(RQ)] for n in xrange(RQ)] for p in xrange(actual_readlen - 1)] for p in xrange(1, actual_readlen): for i in xrange(RQ): rowSum = float(np.sum(totalQ[p][i, :])) + PROB_SMOOTH * RQ if rowSum <= 0.: continue for j in xrange(RQ): probQ[p][i][j] = (totalQ[p][i][j] + PROB_SMOOTH) / rowSum initQ = [[0. for m in xrange(RQ)] for n in xrange(actual_readlen)] for i in xrange(actual_readlen): rowSum = float(np.sum(priorQ[i, :])) + INIT_SMOOTH * RQ if rowSum <= 0.: continue for j in xrange(RQ): initQ[i][j] = (priorQ[i][j] + INIT_SMOOTH) / rowSum if PLOT_STUFF: mpl.rcParams.update({ 'font.size': 14, 'font.weight': 'bold', 'lines.linewidth': 3 }) mpl.figure(1) Z = np.array(initQ).T X, Y = np.meshgrid(range(0, len(Z[0]) + 1), range(0, len(Z) + 1)) mpl.pcolormesh(X, Y, Z, vmin=0., vmax=0.25) mpl.axis([0, len(Z[0]), 0, len(Z)]) mpl.yticks(range(0, len(Z), 10), range(0, len(Z), 10)) mpl.xticks(range(0, len(Z[0]), 10), range(0, len(Z[0]), 10)) mpl.xlabel('Read Position') mpl.ylabel('Quality Score') mpl.title('Q-Score Prior Probabilities') mpl.colorbar() mpl.show() VMIN_LOG = [-4, 0] minVal = 10**VMIN_LOG[0] qLabels = [ str(n) for n in range(QRANGE[0], QRANGE[1] + 1) if n % 5 == 0 ] print qLabels qTicksx = [int(n) + 0.5 for n in qLabels] qTicksy = [(RQ - int(n)) - 0.5 for n in qLabels] for p in xrange(1, actual_readlen, 10): currentDat = np.array(probQ[p]) for i in xrange(len(currentDat)): for j in xrange(len(currentDat[i])): currentDat[i][j] = max(minVal, currentDat[i][j]) # matrix indices: pcolormesh plotting: plot labels and axes: # # y ^ ^ # --> x | y | # x | --> --> # v y x # # to plot a MxN matrix 'Z' with rowNames and colNames we need to: # # pcolormesh(X,Y,Z[::-1,:]) # invert x-axis # # swap x/y axis parameters and labels, remember x is still inverted: # xlim([yMin,yMax]) # ylim([M-xMax,M-xMin]) # xticks() # mpl.figure(p + 1) Z = np.log10(currentDat) X, Y = np.meshgrid(range(0, len(Z[0]) + 1), range(0, len(Z) + 1)) mpl.pcolormesh(X, Y, Z[::-1, :], vmin=VMIN_LOG[0], vmax=VMIN_LOG[1], cmap='jet') mpl.xlim([QRANGE[0], QRANGE[1] + 1]) mpl.ylim([RQ - QRANGE[1] - 1, RQ - QRANGE[0]]) mpl.yticks(qTicksy, qLabels) mpl.xticks(qTicksx, qLabels) mpl.xlabel('\n' + r'$Q_{i+1}$') mpl.ylabel(r'$Q_i$') mpl.title('Q-Score Transition Frequencies [Read Pos:' + str(p) + ']') cb = mpl.colorbar() cb.set_ticks([-4, -3, -2, -1, 0]) cb.set_ticklabels([ r'$10^{-4}$', r'$10^{-3}$', r'$10^{-2}$', r'$10^{-1}$', r'$10^{0}$' ]) #mpl.tight_layout() mpl.show() print 'estimating average error rate via simulation...' Qscores = range(RQ) #print (len(initQ), len(initQ[0])) #print (len(probQ), len(probQ[1]), len(probQ[1][0])) initDistByPos = [ DiscreteDistribution(initQ[i], Qscores) for i in xrange(len(initQ)) ] probDistByPosByPrevQ = [None] for i in xrange(1, len(initQ)): probDistByPosByPrevQ.append([]) for j in xrange(len(initQ[0])): if np.sum( probQ[i][j] ) <= 0.: # if we don't have sufficient data for a transition, use the previous qscore probDistByPosByPrevQ[-1].append( DiscreteDistribution([1], [Qscores[j]], degenerateVal=Qscores[j])) else: probDistByPosByPrevQ[-1].append( DiscreteDistribution(probQ[i][j], Qscores)) countDict = {} for q in Qscores: countDict[q] = 0 for samp in xrange(1, N_SAMP + 1): if samp % PRINT_EVERY == 0: print samp myQ = initDistByPos[0].sample() countDict[myQ] += 1 for i in xrange(1, len(initQ)): myQ = probDistByPosByPrevQ[i][myQ].sample() countDict[myQ] += 1 totBases = float(sum(countDict.values())) avgError = 0. for k in sorted(countDict.keys()): eVal = 10.**(-k / 10.) #print k, eVal, countDict[k] avgError += eVal * (countDict[k] / totBases) print 'AVG ERROR RATE:', avgError return (initQ, probQ, avgError)
x1, x2 = np.meshgrid(t1, t2) # 生成网格采样点 x_test = np.stack((x1.flat, x2.flat), axis=1) # 测试点 # # 无意义,只是为了凑另外两个维度 # x3 = np.ones(x1.size) * np.average(x[:, 2]) # x4 = np.ones(x1.size) * np.average(x[:, 3]) # x_test = np.stack((x1.flat, x2.flat, x3, x4), axis=1) # 测试点 mpl.rcParams['font.sans-serif'] = [u'simHei'] mpl.rcParams['axes.unicode_minus'] = False cm_light = mpl.colors.ListedColormap(['#77E0A0', '#FF8080', '#A0A0FF']) cm_dark = mpl.colors.ListedColormap(['g', 'r', 'b']) y_hat = lr.predict(x_test) # 预测值 y_hat = y_hat.reshape(x1.shape) # 使之与输入的形状相同 plt.figure(facecolor='w') plt.pcolormesh(x1, x2, y_hat, cmap=cm_light) # 预测值的显示 plt.scatter(x[:, 0], x[:, 1], c=y, edgecolors='k', s=50, cmap=cm_dark) # 样本的显示 plt.xlabel(u'花萼长度', fontsize=14) plt.ylabel(u'花萼宽度', fontsize=14) plt.xlim(x1_min, x1_max) plt.ylim(x2_min, x2_max) plt.grid() patchs = [ mpatches.Patch(color='#77E0A0', label='Iris-setosa'), mpatches.Patch(color='#FF8080', label='Iris-versicolor'), mpatches.Patch(color='#A0A0FF', label='Iris-virginica') ] plt.legend(handles=patchs, fancybox=True, framealpha=0.8) plt.title(u'鸢尾花Logistic回归分类效果 - 标准化', fontsize=17) plt.show()
svm2_grid_hat = svm2_grid_hat.reshape(x1.shape) svm3_grid_hat = svm3.predict(grid_show) svm3_grid_hat = svm3_grid_hat.reshape(x1.shape) svm4_grid_hat = svm4.predict(grid_show) svm4_grid_hat = svm4_grid_hat.reshape(x1.shape) cm_light = mpl.colors.ListedColormap(['#00ffcc', '#ffa0a0', '#a0a0ff']) cm_dark = mpl.colors.ListedColormap(['g', 'r', 'b']) plt.figure(facecolor='w', figsize=(14, 7)) ##linnear-svm plt.subplot(221) ##区域图 plt.pcolormesh(x1, x2, svm1_grid_hat, cmap=cm_light) ##所有样本点 plt.scatter(x[0], x[1], c=y, edgecolors='k', s=50, cmap=cm_dark) #样本 ##测试数据集 plt.scatter(x_test[0], x_test[1], s=120, facecolors='none', zorder=10) #圈中测试样本 ##lable列表 plt.xlabel(iris_feature[0], fontsize=13) plt.ylabel(iris_feature[1], fontsize=13) plt.xlim(x1_min, x1_max) plt.ylim(x2_min, x2_max) plt.title('鸢尾花数据linear-SVM分类', fontsize=16) plt.grid(b=True, ls=':') plt.tight_layout(pad=1.5) ##rbf-svm plt.subplot(222)
if bin_gap is not None: min_e, max_e = np.min(energy_grid), np.max(energy_grid) num_bins = int(((max_e - min_e) / bin_gap)**1. / 2.) + 1 bins = [min_e + i**2. * bin_gap for i in np.arange(num_bins)] else: bins = np.linspace(np.min(energy_grid) - 0.1, np.max(energy_grid), 20, endpoint=True) if suffix is not None: savepath = '%s/energy_%s.png' % (saveto, suffix) else: savepath = '%s/energy.png' % (saveto) plt.pcolormesh(dx, dy, energy_grid) CS = plt.contour(dx, dy, energy_grid, bins, colors='white') plt.clabel(CS, inline=1, fontsize=10, fontcolor='white') plt.savefig(savepath, format='png') plt.clf() def plot_data((gen_data, real_data, axis), saveto, suffix=None): if suffix is not None: savepath = '%s/comparison_%s.png' % (saveto, suffix) else: savepath = '%s/comparison.png' % (saveto) plt.plot(gen_data[:, 0], gen_data[:, 1],
mc_local_endpoints['x'].append(output_track_x) mc_local_endpoints['y'].append(output_track_y) mc_local_endpoints['z'].append(output_track_z) # print numner of events processed print(" ----- processed events (pixelhit):" + str(PixelHit.GetEntries()) + " empty_mc_branch:" + str(empty_mc_branch)) print("Plotting...") # plot pixel collected charge versus MC parcticle endpoint coordinates if print_all or print_og or print_2d: mc_hit_histogram = plt.figure(figsize=(11, 7)) H2, xedges, yedges, binnmmber = stats.binned_statistic_2d(mc_local_endpoints['x'], mc_local_endpoints['y'], values=pixel_hit['signal'], statistic='mean', bins=[100, 100]) XX, YY = np.meshgrid(xedges, yedges) Hm = ma.masked_where(np.isnan(H2), H2) plt.pcolormesh(XX, YY, Hm, cmap="inferno") plt.ylabel("pixel y [mm]") plt.xlabel("pixel x [mm]") cbar = plt.colorbar(pad=.015, aspect=20) cbar.set_label("hit signal") if save_pdf: mc_hit_histogram.savefig(path.join(outDir , "GlobalHeatMap.pdf"), bbox_inches='tight') if print_all or print_og or print_2d: mc_hit_histogram_z = plt.figure(figsize=(11, 7)) H2, xedges, yedges, binnmmber = stats.binned_statistic_2d(mc_local_endpoints['x'], mc_local_endpoints['z'], values=pixel_hit['signal'], statistic='mean', bins=[100, 100]) XX, YY = np.meshgrid(xedges, yedges) Hm = ma.masked_where(np.isnan(H2), H2) plt.pcolormesh(XX, YY, Hm.T, cmap="inferno") plt.ylabel("pixel z [mm]") plt.xlabel("pixel x [mm]")
X = np.array([x, x]) y0 = np.zeros(len(x)) y = np.abs(z) Y = np.array([y0, y]) Z = np.array([z, z]) C = np.angle(Z) # Affichages des informations du graph plt.rcParams.update({'mathtext.default': 'regular'}) # Activer la syntax LateX plt.title("$y = e^{-i2 \pi x} e^{-x^{2}}$") #CHANGER ICI plt.xlabel("x") plt.ylabel("Module de y") # Affichage du module plt.plot(x, y, "k") # Affichage de l'argument plt.pcolormesh(X, Y, C, shading="gouraud", cmap=plt.cm.hsv, vmin=-np.pi, vmax=np.pi) plt.colorbar().set_label("Argument de y") plt.show()
else: title = '线性核,C=%.1f' % param[1] clf.fit(x, y) y_hat = clf.predict(x) print('准确率:', accuracy_score(y, y_hat)) # 画图 print(title) print('支撑向量的数目:', clf.n_support_) print('支撑向量的系数:', clf.dual_coef_) print('支撑向量:', clf.support_) plt.subplot(3, 4, i + 1) grid_hat = clf.predict(grid_test) # 预测分类值 grid_hat = grid_hat.reshape(x1.shape) # 使之与输入的形状相同 plt.pcolormesh(x1, x2, grid_hat, cmap=cm_light, alpha=0.8) plt.scatter(x[0], x[1], c=y, edgecolors='k', s=40, cmap=cm_dark) # 样本的显示 plt.scatter(x.loc[clf.support_, 0], x.loc[clf.support_, 1], edgecolors='k', facecolors='none', s=100, marker='o') # 支撑向量 z = clf.decision_function(grid_test) # print 'z = \n', z print('clf.decision_function(x) = ', clf.decision_function(x)) print('clf.predict(x) = ', clf.predict(x)) z = z.reshape(x1.shape) plt.contour(x1, x2,
plt.subplot(2, 2, 1) plt.plot(t, x) plt.axis([0, x.size / float(fs), min(x), max(x)]) plt.ylabel('amplitud') plt.xlabel('tiempo') plt.title('audio: x') # graficar espectrograma en el rango definido plt.subplot(2, 2, 2) numFrames = int(mX[:, 0].size) frmTime = H * np.arange(numFrames) / float(fs) bins = (Freq > rango[0]) & (Freq < rango[1]) Sxx = np.transpose(mX[:, bins]) plt.pcolormesh(frmTime, Freq[bins], Sxx) plt.ylabel('Frequencia [Hz]') plt.xlabel('Time [sec]') plt.autoscale(tight=True) #graficar el promedio del espectro de todo el archivo de audio mX = np.mean(mX, axis=0) plt.subplot(2, 2, 3) plt.plot(Freq[bins], mX[bins]) plt.xlabel('Frequencia [Hz]') plt.ylabel('Magnitud en dB') ########################################## #BLOQUE 2 '''
def main(inputFile1='../../sounds/ocean.wav', inputFile2='../../sounds/speech-male.wav', window1='hamming', window2='hamming', M1=1024, M2=1024, N1=1024, N2=1024, H1=256, smoothf = .5, balancef = 0.2): """ Function to perform a morph between two sounds inputFile1: name of input sound file to be used as source inputFile2: name of input sound file to be used as filter window1 and window2: windows for both files M1 and M2: window sizes for both files N1 and N2: fft sizes for both sounds H1: hop size for sound 1 (the one for sound 2 is computed automatically) smoothf: smoothing factor to be applyed to magnitude spectrum of sound 2 before morphing balancef: balance factor between booth sounds, 0 is sound 1 and 1 is sound 2 """ # read input sounds (fs, x1) = UF.wavread(inputFile1) (fs, x2) = UF.wavread(inputFile2) # compute analysis windows w1 = get_window(window1, M1) w2 = get_window(window2, M2) # perform morphing y = STFTT.stftMorph(x1, x2, fs, w1, N1, w2, N2, H1, smoothf, balancef) # compute the magnitude and phase spectrogram of input sound (for plotting) mX1, pX1 = STFT.stftAnal(x1, fs, w1, N1, H1) # compute the magnitude and phase spectrogram of output sound (for plotting) mY, pY = STFT.stftAnal(y, fs, w1, N1, H1) # write output sound outputFile = 'output_sounds/' + os.path.basename(inputFile1)[:-4] + '_stftMorph.wav' UF.wavwrite(y, fs, outputFile) # create figure to plot plt.figure(figsize=(12, 9)) # frequency range to plot maxplotfreq = 10000.0 # plot sound 1 plt.subplot(4,1,1) plt.plot(np.arange(x1.size)/float(fs), x1) plt.axis([0, x1.size/float(fs), min(x1), max(x1)]) plt.ylabel('amplitude') plt.xlabel('time (sec)') plt.title('input sound: x') # plot magnitude spectrogram of sound 1 plt.subplot(4,1,2) numFrames = int(mX1[:,0].size) frmTime = H1*np.arange(numFrames)/float(fs) binFreq = fs*np.arange(N1*maxplotfreq/fs)/N1 plt.pcolormesh(frmTime, binFreq, np.transpose(mX1[:,:N1*maxplotfreq/fs+1])) plt.xlabel('time (sec)') plt.ylabel('frequency (Hz)') plt.title('magnitude spectrogram of x') plt.autoscale(tight=True) # plot magnitude spectrogram of morphed sound plt.subplot(4,1,3) numFrames = int(mY[:,0].size) frmTime = H1*np.arange(numFrames)/float(fs) binFreq = fs*np.arange(N1*maxplotfreq/fs)/N1 plt.pcolormesh(frmTime, binFreq, np.transpose(mY[:,:N1*maxplotfreq/fs+1])) plt.xlabel('time (sec)') plt.ylabel('frequency (Hz)') plt.title('magnitude spectrogram of y') plt.autoscale(tight=True) # plot the morphed sound plt.subplot(4,1,4) plt.plot(np.arange(y.size)/float(fs), y) plt.axis([0, y.size/float(fs), min(y), max(y)]) plt.ylabel('amplitude') plt.xlabel('time (sec)') plt.title('output sound: y') plt.tight_layout() plt.show(block=False)
from sklearn.model_selection import train_test_split import numpy as np # 生成样本数量为500, 分类数为5的数据集 X, y = make_blobs(n_samples=500, centers=5, random_state=8) # 将数据集拆分成训练集和测试集 X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=8) # 使用高斯朴素贝叶斯 gnb = GaussianNB() gnb.fit(X_train, y_train) print('\n代码运行结果: ') print('训练集数据得分:{:.3f}'.format(gnb.score(X_train, y_train))) print('测试及数据得分:{:.3f}'.format(gnb.score(X_test, y_test))) # 限定横轴与纵轴的最大值 x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5 y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5 # 用不同的背景色表示不同的分类 xx, yy = np.meshgrid(np.arange(x_min, x_max, .02), np.arange(y_min, y_max, .02)) z = gnb.predict(np.c_[(xx.ravel(), yy.ravel())]).reshape(xx.shape) plt.pcolormesh(xx, yy, z, cmap=plt.cm.Spectral) # 将训练集和测试集用散点图表示 plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=plt.cm.cool, edgecolors='k') plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=plt.cm.cool, marker='*', edgecolors='k') plt.xlim(xx.min(), xx.max()) plt.ylim(yy.min(), yy.max()) plt.title('Classifier GaussianNB') plt.show()
sampler = MetropolisSampler(D=2, sigma=np.array([[1, 0], [0, 1]]), p=p) samples = sampler.sample(np.array([1, 0]), N=5000, stride=10) fig = plt.figure(figsize=(12, 5)) print(f"sample mean : {np.mean(samples, axis=0)}") print(f"sample covariance : {np.cov(samples, rowvar=False)}") # two dimensional histogram H, xx, yy = np.histogram2d(samples[:, 0], samples[:, 1], bins=25, normed=True) H = H.T XX, YY = np.meshgrid(xx, yy) # contour plot of the density function xx_f = np.linspace(-1.5, 1.5, 100) yy_f = np.linspace(-1.5, 1.5, 101) XX_f, YY_f = np.meshgrid(xx_f, yy_f) Z_f = np.exp( -0.5 * (10 * XX_f * XX_f - 12 * XX_f * YY_f + 10 * YY_f * YY_f)) / (2 * np.pi) * 8 plt.subplot(121) plt.plot(samples[:, 0], samples[:, 1], ',') plt.contour(XX_f, YY_f, Z_f) plt.colorbar() plt.subplot(122) plt.pcolormesh(XX, YY, H) plt.colorbar() plt.contour(XX_f, YY_f, Z_f) fig.savefig("2D_normal_sampling.png")