def test_bdevolpar_accuracy(modelname='baraffe', parameter='temperature',metallicity=0.,clouds='nocloud'): # model = readModel('saumon',metallicity='solar',cloud='hybrid') model = readModel(modelname,metallicity=metallicity,clouds=clouds) masses = model['mass'][-2] vals = [] for i,age in enumerate(model['age']): t = [] for j,m in enumerate(masses): if m in model['mass'][i]: t.append(numpy.array(model[parameter][i])[numpy.where(model['mass'][i]==m)]) else: t.append(numpy.nan) vals.append(t) vl = numpy.array(vals).T for j,m in enumerate(masses): if parameter=='temperature' or parameter=='radius': plt.loglog(model['age'],vl[j],color='grey') else: plt.semilogx(model['age'],vl[j],color='grey') age_samp = 10.**(numpy.arange(1,100)/100.*4-3.) mass_samp = [0.003,0.005,0.01,0.02,0.05,0.08,0.1,0.2] for m in mass_samp: p = modelParameters(model,age=age_samp,mass=[m for i in range(len(age_samp))]) if parameter=='temperature' or parameter=='radius': plt.loglog(age_samp,p[parameter],color='r') else: plt.semilogx(age_samp,p[parameter],color='r') plt.ylabel(parameter) plt.xlabel('Age') plt.show() return True
def plotPeriodogram(fvec, pvec, axes=None, thinning=None): ''' **plotPeriodogram(fvec, pvec, axes=None, thinning=None)** Function that plot a periodogram Parameters ---------- **fvec** : vector containing the frequencies resulting from fftdem() \n **pvec** : vector containing the power values resulting from fftdem() \n **axes** : string indicating what type of axes to use. Possible options are: \n\t - "loglog" \n\t - "semilogx"\n\t - "semilogy" \n\t - None (default option)\n **thinning** : parameter to thin the data o plot as vectors can be ver large. It will plot only the number of dots indicated by thinning ''' # Wvec=1/fvec if thinning == None: thinning = thinningCheckup(fvec) plt.figure() if axes == "loglog": plt.loglog(fvec[range(0,fvec.size,thinning)],pvec[range(0,pvec.size,thinning)]) elif axes == "semilogx": plt.semilogx(fvec[range(0,fvec.size,thinning)],pvec[range(0,pvec.size,thinning)]) elif axes == "semilogy": plt.semilogy(fvec[range(0,fvec.size,thinning)],pvec[range(0,pvec.size,thinning)]) else: plt.plot(fvec[range(0,fvec.size,thinning)],pvec[range(0,pvec.size,thinning)]) plt.title("Periodogram") plt.ylabel("DFT mean square amplitude") plt.xlabel("Frequency (1/m)") plt.show()
def plotBode2(zpk, n=200, f_range=None, f_logspace=True): """ Bode plot of ZerosAndPoles object using matplotlib """ (f, y) = zpk.frequencyResponse(n=n, f_range=f_range, f_logspace=f_logspace) y_A = numpy.abs(y) y_phi = Misc.to_deg(Misc.continuousAngle(y)) plt.figure() plt.subplot(211) if f_logspace: plt.loglog(f, y_A) else: plt.plot(f, y_A) plt.grid(True, which="both") plt.ylabel("Amplitude") plt.subplot(212) if f_logspace: plt.semilogx(f, y_phi) else: plt.plot(f, y_A) plt.grid(True, which="both") plt.xlabel("Frequency [Hz]") plt.ylabel("Phase [deg]") plt.show()
def comp_conv(f,a,b,exact_value): nmax = 100 x = np.arange(1.0, nmax, 1.0) t = np.arange(1.0, nmax, 1.0) u = np.arange(1.0, nmax, 1.0) v = np.arange(1.0, nmax, 1.0) w = np.arange(1.0, nmax, 1.0) for i in np.arange(0.0,t.size): t[i] = rect_meth(a,b,x[i],f) for i in np.arange(0.0,u.size): u[i] = simpson_meth(a,b,x[i],f) for i in np.arange(0.0,v.size): v[i] = midpoint_meth(a,b,x[i],f) for i in np.arange(0.0,v.size): w[i] = exact_value mp.clf() mp.semilogx() mp.plot(x, t, linewidth=1.0, label='Rectangle') mp.plot(x, u, linewidth=1.0, label='Simpson') mp.plot(x, v, linewidth=1.0, label='Midpoint') mp.plot(x, w, linewidth=1.0, label='Value of the integral') mp.title("Illustration of the convergence of the three integration methods"); mp.xlabel('Number of subdivision points') mp.ylabel('Integral of f between a and b') mp.legend(loc='upper right') mp.show()
def demon(n, d, g, kgiven=0): ks = np.arange(n + 1) c1, c2 = [], [] for k in ks: a = hyp2f1(1, n - k + 1, n + 2, 1 - d) b = 0 if g == 0 else hyp2f1(1, n - k + 1, n + 2, 1 - d * g) c1.append(a * d - b * d * g) c2.append(a) plt.plot(ks / n, c1, label='c1') plt.plot(ks / n, c2, label='c2') plt.xlabel('k / n') plt.ylabel('Effective n / n') plt.legend() plt.figure() S = [100 * generalised_entropy_gain(n, k, d, g) for k in ks] plt.plot(ks / n, S, label='S') plt.xlabel('k / n') plt.ylabel('information gain') plt.figure() dif = np.logspace(-1, 1, 100) S = [100 * generalised_entropy_gain(n, kgiven, d, g) for d in dif] plt.semilogx(dif, S, label='S') plt.xlabel('difficulty') plt.ylabel('information gain')
def plotPredictions(self): plt.semilogx(self.freqsISO, self.thresholdsISO, label = 'ISO') plt.semilogx(self.freqsISO, self.predictions, color = 'r', linestyle = '--', label = 'Predicted') plt.legend() plt.show()
def plot_validation_curve(model, X, y, scorer, param_name, param_range=np.linspace(0.1, 1, 5), cv=None, n_jobs=5, ylim=None, title="Xval. validation curve"): ''' Plot learning curve for model on data ''' df = pd.DataFrame() df['param_range'] = param_range train_scores, test_scores = validation_curve(model, X, y, param_name=param_name, param_range=param_range, cv=cv, scoring=scorer, n_jobs=n_jobs) df['train_mean'] = 1 - np.mean(train_scores, axis=1) df['train_std'] = np.std(train_scores, axis=1) df['test_mean'] = 1 - np.mean(test_scores, axis=1) df['test_std'] = np.std(test_scores, axis=1) plt.figure() plt.title(title) if ylim is not None: plt.ylim(*ylim) plt.xlabel("Parameter value") plt.ylabel("Error (1-score)") plt.grid() plt.semilogx(param_range, df.train_mean, color="r", label="Training") plt.fill_between(param_range, df.train_mean - df.train_std, df.train_mean + df.train_std, alpha=0.1, color="r") plt.semilogx(param_range, df.test_mean, color="g", label="Test") plt.fill_between(param_range, df.test_mean - df.test_std, df.test_mean + df.test_std, alpha=0.1, color="g") plt.legend(loc="best") plt.show() return df, plt
def plot_cum_vw_data(zrange=None): """Plot a cumulative velocity width distribution with error""" (_, _, data) = load_data(zrange) v_table = 10**np.arange(1, np.log10(np.max(data)+10), 0.1) (center, cvels) = pdf_with_error(data, v_table, cumulative=True) plt.semilogx(center, cvels, ls="-",color="black", label="N13") return (center, cvels)
def plotPredictions(self): plt.semilogx(self.freqs, self.sPLs, label = 'ISO target') plt.semilogx(self.freqs, self.predictions, color = 'r', linestyle = '--', label = 'Predicted') plt.legend() plt.show()
def plot_graph(input_size_list, run_time_list): input_size_list = np.array(input_size_list) run_time_list = np.array(run_time_list) plt.semilogx(input_size_list, [0]*len(input_size_list)) return plt.plot(input_size_list, run_time_list)
def main(): edges = [30, 60, 120, 240] corners = zip(edges[:-1], edges[1:]) centres = [(a + b) / 2 for a, b in corners] #c = [get_linkwitz_riley_coeffs(1, b, a, edges[-1] * 2) for b, a in corners] sr = 2000 c = [get_peak_coeffs(-24, i, sr, 1) for i in centres] c.append([[1, 0, 0], [1, 0, 0]]) bm = [BiquadMemory(0, 0) for _ in c] bc = [BiquadCoefficients(b0, b1, b2, a1, a2) for [b0, b1, b2], [a0, a1, a2] in c] c.append(series_coeffs(c)) # c.append(impedance_filter(c[-1])) wh = [signal.freqz(b, a) for b, a in c] plt.subplot(111) plt.title("Frequency response - reflection filter") for w, h in wh: plt.semilogx(w, 20 * np.log10(np.abs(h))) plt.ylabel('Amplitude Response (dB)') plt.xlabel('Frequency (rad/sample)') plt.grid() plt.show()
def plotRI(RI, title='', filename=''): global subdirectory directory = pinspec.get_output_directory() + subdirectory # Make directory if it does not exist if not os.path.exists(directory): os.makedirs(directory) # Plot Resonance Integrals fig = plt.figure() bins = RI.bin_edges plt.semilogx(bins[0:-1], RI.RIs, drawstyle='steps-post') plt.xlabel('Energy [eV]') plt.ylabel('RI') plt.grid() if title is '': plt.title('Resonance Integrals') else: plt.title(title.title() + ' Resonance Integrals') if filename is '': filename = directory + 'RI.png' else: filename = directory + filename.replace(' ', '-').lower() +'-RI.png' plt.savefig(filename)
def plotGroupXS(group_xs, title='', filename=''): global subdirectory directory = pinspec.get_output_directory() + subdirectory # Make directory if it does not exist if not os.path.exists(directory): os.makedirs(directory) # Plot Resonance Integrals fig = plt.figure() bins = group_xs.bin_edges plt.semilogx(bins[0:-1], group_xs.groupXS[:,:], drawstyle='steps-post') plt.xlabel('Energy [eV]') plt.ylabel('Group XS') plt.grid() if title is '': plt.title('Group XS') else: plt.title(title.title() + ' Group XS') if filename is '': filename = directory + '/group-xs.png' else: filename = directory + filename.replace(' ', '-').lower() + \ '-group-xs.png' plt.savefig(filename) plt.close(fig)
def plot_validation_curve(estimator, title, X, y, param_name, param_range, cv=10, scoring='accuracy', n_jobs=2): from sklearn.learning_curve import validation_curve train_scores, test_scores = validation_curve( estimator, X, y, param_name, param_range, cv=cv, scoring=scoring, n_jobs=n_jobs) train_scores_mean = np.mean(train_scores, axis=1) train_scores_std = np.std(train_scores, axis=1) test_scores_mean = np.mean(test_scores, axis=1) test_scores_std = np.std(test_scores, axis=1) plt.figure() plt.title(title) plt.xlabel(param_name) plt.ylabel("Score") plt.ylim(0.0, 1.1) plt.semilogx(param_range, train_scores_mean, label="Training score", color="r") plt.fill_between(param_range, train_scores_mean - train_scores_std, train_scores_mean + train_scores_std, alpha=0.2, color="r") plt.semilogx(param_range, test_scores_mean, label="Cross-validation score", color="g") plt.fill_between(param_range, test_scores_mean - test_scores_std, test_scores_mean + test_scores_std, alpha=0.2, color="g") plt.legend(loc="best") plt.show()
def plot_containment_radii(fraction): """Plotting script for 68% and 95% containment radii.""" psf_gc = FermiGalacticCenter.psf() gtpsf_table_gc = get_psf_table(psf_gc, 10000, 300000, 15) psf_vela = FermiVelaRegion.psf() gtpsf_table_vela = get_psf_table(psf_vela, 10000, 300000, 15) if fraction == 68: true_table_rep = load_lat_psf_performance('P7REP_SOURCE_V15_68') true_table = load_lat_psf_performance('P7SOURCEV6_68') rad = 'CONT_68' elif fraction == 95: true_table_rep = load_lat_psf_performance('P7REP_SOURCE_V15_95') true_table = load_lat_psf_performance('P7SOURCEV6_95') rad = 'CONT_95' plt.plot(gtpsf_table_gc['ENERGY'], gtpsf_table_gc[rad], color='red',label='Fermi Tools PSF @ Galactic Center') plt.plot(gtpsf_table_vela['ENERGY'], gtpsf_table_vela[rad], color='blue', label='Fermi Tools PSF @ Vela Region') plt.plot(true_table_rep['energy'], true_table_rep['containment_angle'], color='green', linestyle='--', label='P7REP_SOURCE_V15') plt.plot(true_table['energy'], true_table['containment_angle'], color='black', linestyle='--', label='P7SOURCEV6') plt.xlim([10000, 300000]) plt.legend() plt.semilogx() plt.xlabel('Energy/MeV') plt.ylabel('PSF Containment Radius/deg') return plt
def colormap(data, alphas, R0s, p = True, logx = True, ret = False): """ Use pcolormesh from matplotlib to create a visualization of the SIRS phase diagram in the form of a heat map. Input: data : Dictionary of the form {(alpha, R0}:value}, where the value represents <I*>, <S*>, etc. This dictionary is produced by avg_idata(), fluct(), or frac_fluct() alphas: Phase diagram parameters on x-axis; rho/gamma R0s : Phase diagram parameters on y-axis; beta<k>/gamma These can be obtained with data_params() p : Create a plot of the data if p==True logx : Plot with a logarithmic x-axis (alphas logarithmic) ret : If ret==True, return the values used to create the heat map, so that they may be manipulated in the interpreter or elsewhere; defaults to False Output: Creates a matplotlib heatmap if p==True (X, Y, C): These are three arrays that pcolormesh() takes as arguments. These are returned only if ret==True """ X, Y = np.meshgrid(alphas, R0s) C = np.array([[data[rho_, R0] for rho_ in alphas] for R0 in R0s]) if p: plt.figure() plt.pcolormesh(X, Y, C) plt.xlabel('rho/gamma') if logx: plt.semilogx() plt.ylabel('R_0') plt.colorbar() plt.show() if ret: return X, Y, C
def cmc(cmc_scores, logx = True, **kwargs): """Plots the (cumulative) match characteristics curve and returns the maximum rank. This function plots a CMC curve using the given CMC scores, which can be read from the our score files using the :py:func:`bob.measure.load.cmc_four_column` or :py:func:`bob.measure.load.cmc_five_column` methods. The structure of the ``cmc_scores`` parameter is relatively complex. It contains a list of pairs of lists. For each probe object, a pair of list negative and positive scores is required. **Parameters:** ``cmc_scores`` : [(array_like(1D, float), array_like(1D, float))] See :py:func:`bob.measure.cmc` ``logx`` : bool Plot the rank axis in logarithmic scale using :py:func:`matplotlib.pyplot.semilogx` or in linear scale using :py:func:`matplotlib.pyplot.plot`? (Default: ``True``) ``kwargs`` : keyword arguments Extra plotting parameters, which are passed directly to :py:func:`matplotlib.pyplot.plot` or :py:func:`matplotlib.pyplot.semilogx`. **Returns:** The number of classes (clients) in the given scores. """ from matplotlib import pyplot from . import cmc as calc out = calc(cmc_scores) if logx: pyplot.semilogx(range(1, len(out)+1), out * 100, **kwargs) else: pyplot.plot(range(1, len(out)+1), out * 100, **kwargs) return len(out)
def binning(data, quantity, show_plot=False, save_plot=False): """ Calculate autocorrelation time, mean and error for a quantity using the binning method. The bins become uncorrelated when the error approaches a constant. These uncorrelated bins can be used for jackknife resampling. """ original_length = len(data) errors = [] errors.append((original_length, calculate_error(data))) while len(data) > 128: data = np.asarray([(a + b) / 2 for a, b in zip(data[::2], data[1::2])]) errors.append((len(data), calculate_error(data))) autocorrelation_time = 0.5 * ((errors[-1][1] / errors[0][1])**2 - 1) if np.isnan(autocorrelation_time) or autocorrelation_time <= 0: autocorrelation_time = 1 if show_plot: # plt.title(r'${0}$'.format('\mathrm{' + quantity.replace(' ', '\ ') + '\ Error}')) plt.xlabel(r'$\mathrm{Number\ of\ Data\ Points}$') plt.ylabel(r'$\mathrm{Error}$') plt.xlim(original_length, 1) plt.ylim(ymin=0, ymax=max(errors, key=lambda x: x[1])[1] * 1.15) plt.semilogx([e[0] for e in errors], [e[1] for e in errors], basex=2) sns.despine() if save_plot: plt.savefig("{0}/{1}_{2}_binning_error.pdf".format(SAVE_LOCATION, time.strftime("%Y%m%d%H%M%S", time.localtime(time.time())), quantity.replace(" ", "_"), bbox_inches='tight')) plt.show() return np.mean(data), errors[-1][1], autocorrelation_time, data
def plot_marginal(self, param, lower_bound=0, upper_bound=1, is_int=False, resolution=100): if isinstance(param, int): dim = param param_name = self._fanova.get_config_space().get_parameter_names()[dim] else: assert param in self._fanova.param_name2dmin, "param %s not known" % param dim = self._fanova.param_name2dmin[param] param_name = param grid = np.linspace(lower_bound, upper_bound, resolution) display_grid = [self._fanova.get_config_space().unormalize_value(param_name, value) for value in grid] mean = np.zeros(resolution) std = np.zeros(resolution) for i in xrange(0, resolution): (m, s) = self._fanova.get_marginal_for_value(dim, grid[i]) mean[i] = m std[i] = s mean = np.asarray(mean) std = np.asarray(std) lower_curve = mean - std upper_curve = mean + std if np.diff(display_grid).std() > 0.000001 and param_name in self._fanova.get_config_space().get_continuous_parameters(): #HACK for detecting whether it's a log parameter, because the config space doesn't expose this information plt.semilogx(display_grid, mean, 'b') print "printing %s semilogx" % param_name else: plt.plot(display_grid, mean, 'b') plt.fill_between(display_grid, upper_curve, lower_curve, facecolor='red', alpha=0.6) plt.xlabel(param_name) plt.ylabel("Performance") return plt
def hypers_demo(): steps, mc = 500, 20 ssm = UNGM() # initialize UNGM model x, z = ssm.simulate(steps, mc_sims=mc) # generate some data lscale = [1e-3, 3e-3, 1e-2, 3e-2, 1e-1, 3e-1, 1, 3, 1e1, 3e1] # , 1e2, 3e2] sigmas_ut = Unscented.unit_sigma_points(ssm.xD, kappa=0.0) mean_f, cov_f = np.zeros((ssm.xD, steps, mc, len(lscale))), np.zeros((ssm.xD, ssm.xD, steps, mc, len(lscale))) for iel, el in enumerate(lscale): # initialize BHKF with current lenghtscale f = GPQuadKalman(ssm, usp_dyn=sigmas_ut, usp_meas=sigmas_ut, hyp_dyn={'sig_var': 1.0, 'lengthscale': el * np.ones(ssm.xD, ), 'noise_var': 1e-8}, hyp_meas={'sig_var': 1.0, 'lengthscale': el * np.ones(ssm.xD, ), 'noise_var': 1e-8}) # filtering for s in range(mc): mean_f[..., s, iel], cov_f[..., s, iel] = f.forward_pass(z[..., s]) # compute average (over MC sims) RMSE and NCI rmseVsEl = rmse(x, mean_f).mean(axis=1) nciVsEl = nci(x, mean_f, cov_f).mean(axis=1) # plot influence of changing lengthscale on the RMSE and NCI filter performance plt.figure() plt.semilogx(lscale, rmseVsEl.squeeze(), color='k', ls='-', lw=2, marker='o', label='RMSE') plt.semilogx(lscale, nciVsEl.squeeze(), color='k', ls='--', lw=2, marker='o', label='NCI') plt.grid(True) plt.legend() plt.show() return lscale, rmseVsEl, nciVsEl
def MakeAndPlotReadCountHistogram(readCountArray, plotCumulative=False, plotHistogram=False, \ title='', xlabel='', ylabel='', cumTitle='', cumXlabel='', cumYlabel='', binWidth=1): import numpy import matplotlib.pyplot as plt bins = numpy.arange(0, max(readCountArray)+binWidth, binWidth) values, base = numpy.histogram(readCountArray, bins=bins) cumulative = numpy.cumsum(values) binCenters = ConvertBinEdgesToCenters(base) if plotCumulative: plt.figure() plt.semilogx(base[:-1],cumulative/max(cumulative)) plt.title(cumTitle) plt.xlabel(cumXlabel) plt.ylabel(cumYlabel) plt.show() if plotHistogram: plt.figure() plt.plot(binCenters, values) plt.title(title) plt.xlabel(xlabel) plt.ylabel(ylabel) plt.show() return [bins, values, base, cumulative]
def bode(G, w1, w2, label='Figure', margin=False): """ Shows the bode plot for a plant model Parameters ---------- G : tf plant transfer function w1 : real start frequency w2 : real end frequency label : string title for the figure (optional) margin : boolean show the cross over frequencies on the plot (optional) Returns ------- GM : array containing a real number gain margin PM : array containing a real number phase margin """ GM, PM, wc, w_180 = margins(G) # plotting of Bode plot and with corresponding frequencies for PM and GM # if ((w2 < numpy.log(w_180)) and margin): # w2 = numpy.log(w_180) w = numpy.logspace(w1, w2, 1000) s = 1j*w plt.figure(label) # Magnitude of G(jw) plt.subplot(211) gains = numpy.abs(G(s)) plt.loglog(w, gains) if margin: plt.axvline(w_180, color='black') plt.text(w_180, numpy.average([numpy.max(gains), numpy.min(gains)]), r'$\angle$G(jw) = -180$\degree$') plt.axhline(1., color='red') plt.grid() plt.ylabel('Magnitude') # Phase of G(jw) plt.subplot(212) phaseangle = phase(G(s), deg=True) plt.semilogx(w, phaseangle) if margin: plt.axvline(wc, color='black') plt.text(wc, numpy.average([numpy.max(phaseangle), numpy.min(phaseangle)]), '|G(jw)| = 1') plt.axhline(-180., color='red') plt.grid() plt.ylabel('Phase') plt.xlabel('Frequency [rad/unit time]') plt.show() return GM, PM
def plotValidationCurve(c, training_avgs, validation_avgs, model_name, x_label = 'C'): """ This function plots the training and validation averages Against the parameter we are trying to optimize """ plt.clf() p1, = plt.plot(c, training_avgs, 'ro-', label = 'training') p2, = plt.plot(c, validation_avgs, 'go-', label = 'validation') plt.xlabel(x_label, fontsize = 16) plt.ylabel('Score', fontsize = 16) plt.title(model_name + ' Validation Curve', fontdict = {'fontsize': 16}) plt.legend(loc = 0) plt.semilogx() # now save the figure model_name = re.sub(r'\W', '_', model_name) plt.savefig(model_name + '_validation.png', format = 'png') return None
def Pl(Outfile,line='-.',label=''): dd=np.loadtxt(Outfile+'PS_DD') dk=np.loadtxt(Outfile+'PS_DK') kk=np.loadtxt(Outfile+'PS_KK') halo=np.loadtxt('/home/mtx/data/tide/outdata/test/PS_haloDD') #plt.figure('Power Spectrum') #n=np.ones_like(kk[:,1]) #plt.loglog(dd[:,0],dd[:,1],'b.-',label='P_DD') #plt.loglog(halo[:,0],halo[:,1],'m.-',label='P_halo') #plt.loglog(dk[:,0],dk[:,1],'g.-',label='P_DK') #plt.loglog(kk[:,0],kk[:,1],'r.-',label='P_KK') #plt.loglog(kk[:,0],n*noise3,'k-.',alpha=0.8,label='noise') #plt.title('Power Spectrum') #plt.xlabel('k $(h/Mpc)$') #plt.ylabel('P(k) $(Mpc^{3}/h^{3})$') #plt.legend() #plt.ylim(10**1,6*10**4) #plt.xlim([9*10**-3,1]) ##plt.savefig(name+'PS.eps') plt.figure('correlation coefficient') plt.title('correlation coefficient') plt.semilogx(kk[:,0],dk[:,1]/np.sqrt(dd[:,1]*kk[:,1]),line,label=label) plt.xlabel('k $(h/Mpc)$') plt.ylabel('r')
def plot_fft(self, plotname=None, window='hann', normalise=True, **kwargs): """Make a plot (in the frequency domain) of all channels""" ymin = kwargs.get('ymin', -160) #dB freq, mag = self.fft(window=window, normalise=normalise) fig_id = 1 plt.figure(fig_id) #plt.semilogx(freq, mag, **kwargs) # plots all channel directly plt.hold(True) for ch in range(self.ch): plt.semilogx(freq, mag[:,ch], label='ch%2i' %(ch+1)) plt.hold(False) plt.xlim(xmin=1) # we're not interested in freqs. below 1 Hz plt.ylim(ymin=ymin) plt.xlabel('Frequency [Hz]') plt.ylabel('Magnitude [dB]') plt.legend(loc='best') plt.grid(True) if plotname is None: plt.show() else: plt.savefig(plotname) plt.close(fig_id)
def plotActiveFilters(self, colour='r'): if self.initialized: plt.semilogx(self.freqs, 10 * np.log10(self.wActive + 1e-10), colour) plt.xlabel('Frequency, Hz') plt.ylabel('Response, dB') plt.show()
def make_plot(): def u(t): return sym.exp(-a*t) a, t, dt, p = sym.symbols('a t dt p') dudt = sym.diff(u(t), t) from numpy import logspace, exp from matplotlib.pyplot import ( semilogx, legend, show, loglog, savefig) # Map operator function name to logical names operator2name = dict( D_f='forward', D_b='backward', D_c='central') legends = [] for operator in D_f, D_b, D_c: E = operator(u, dt, t)/dudt # Expand, set p=a*dt, simplify E = sym.expand(E) E = E.subs(a*dt, p) E = sym.simplify(E) print '%s E:' % operator2name[operator.__name__], E print 'Taylor series:', E.series(p, 0, 3) latex_expr = sym.latex(E) E = sym.lambdify([p], E, modules='numpy') p_values = logspace(-6, -0.5, 101) y = E(p_values) semilogx(p_values, y) legends.append(operator2name[operator.__name__] + ': $' + latex_expr + '$') legend(legends, loc='lower left') savefig('tmp.png'); savefig('tmp.pdf') show()
def plotDimensionsUpdateFrequencyEstimation(self, returnAxisValuesOnly=True): ''' numberOfTimeUnits=10*24*12 Experts stream 12 Houston stream 2 ''' dataDistribution = defaultdict(list) for line in FileIO.iterateJsonFromFile(self.dimensionsUpdateFrequencyFile): for k, v in line[ParameterEstimation.dimensionsUpdateFrequencyId].iteritems(): k = int(k) / self.timeUnitInSeconds.seconds if k not in dataDistribution: dataDistribution[k] = [0., 0.] dataDistribution[k][0] += v; dataDistribution[k][1] += 1 x, y = [], []; [(x.append(k), y.append((dataDistribution[k][0] / dataDistribution[k][1]))) for k in sorted(dataDistribution)] x1, y1 = [], []; [(x1.append(k), y1.append((dataDistribution[k][0] / dataDistribution[k][1]) / k)) for k in sorted(dataDistribution)] x = x[:numberOfTimeUnits]; y = y[:numberOfTimeUnits]; x1 = x1[:numberOfTimeUnits]; y1 = y1[:numberOfTimeUnits] def subPlot(id): plt.subplot(id) inactivityCorordinates = max(zip(x1, y1), key=itemgetter(1)) plt.semilogx(x1, y1, '-', color=self.stream_settings['plot_color'], label=getLatexForString(self.stream_settings['plot_label'] + ' (Update frequency=%d TU)' % inactivityCorordinates[0]), lw=2) plt.subplot(id).yaxis.set_major_formatter(FuncFormatter(lambda x, i: '%0.1f' % (x / 10. ** 3))) plt.semilogx([inactivityCorordinates[0]], [inactivityCorordinates[1]], 'o', alpha=0.7, color='r') plt.subplot(id).yaxis.set_major_formatter(FuncFormatter(lambda x, i: '%0.1f' % (x / 10. ** 3))) plt.yticks((min(y1), max(y1))) print self.stream_settings['plot_label'], inactivityCorordinates[0] plt.subplot(311) plt.title(getLatexForString('Dimensions update frequency estimation')) plt.semilogx(x, y, '-', color=self.stream_settings['plot_color'], label=getLatexForString(self.stream_settings['plot_label']), lw=2) plt.subplot(311).yaxis.set_major_formatter(FuncFormatter(lambda x, i: '%0.1f' % (x / 10. ** 5))) plt.text(0.0, 1.01, getLatexForString('10^5'), transform=plt.gca().transAxes) plt.ylabel(getLatexForString('\# of decayed dimensions')) if self.stream_settings['stream_id'] == 'experts_twitter_stream': subPlot(312) else: subPlot(313); plt.xlabel(getLatexForString(xlabelTimeUnits)) plt.ylabel(getLatexForString('Rate of DD (10^3)')) plt.legend(loc=3) if returnAxisValuesOnly: plt.show()
def test_frequency(self): import scipy.signal as ss nsteps = 10000 dt = 0.1 t,w = self.regular_integrator.run(self.regular_w0, dt=dt, nsteps=nsteps) f,fft = fft_orbit(t, w) peak_ix = ss.find_peaks_cwt(fft[:,0], widths=np.linspace(dt*2, dt*100, 10)) print(peak_ix) plt.clf() plt.axvline(self.regular_par[1]/(2*np.pi), linewidth=3., alpha=0.35, color='b') plt.axvline(1/(2*np.pi), linewidth=3., alpha=0.35, color='r') plt.semilogx(f[:,0], fft[:,0], marker=None) plt.savefig(os.path.join(plot_path,"pend_fft_regular.png")) # ---------------------------------------------------------------------- t,w = self.chaotic_integrator.run(self.chaotic_w0, dt=dt, nsteps=nsteps) f,fft = fft_orbit(t, w) peak_ix = ss.find_peaks_cwt(fft[:,0], widths=np.linspace(dt*2, dt*100, 10)) print(peak_ix) plt.clf() plt.axvline(self.chaotic_par[1]/(2*np.pi), linewidth=3., alpha=0.35, color='b') plt.axvline(1/(2*np.pi), linewidth=3., alpha=0.35, color='r') plt.semilogx(f[:,0], fft[:,0], marker=None) plt.savefig(os.path.join(plot_path,"pend_fft_chaotic.png"))
def main(): # define paths dir = 'media/results' sizefile = os.path.join(dir,'sizes.csv') timefile = os.path.join(dir,'times.csv') # load data sizedata = np.loadtxt(open(sizefile,"rb"),delimiter=",") timedata = np.loadtxt(open(timefile,"rb"),delimiter=",") timedata = 1000*timedata # calculate mean and standard deviation mean_time = timedata.mean(axis=0); stdev_time = timedata.std(axis=0); size = [elem[0]*elem[1] for elem in sizedata] t_max = mean_time+stdev_time t_min = mean_time-stdev_time # show data plt.figure(facecolor='white') #plt.fill_between(size, t_min, t_max, facecolor='blue', interpolate=True,alpha = 0.5) plt.fill_between(size, t_min, t_max, facecolor='#8080FF',color='blue',linewidth=0.5, interpolate=True) plt.semilogx(size,mean_time, color='blue',linewidth=1) plt.title('Computational time vs number of pixels') plt.ylim([0,1]) plt.xlim([min(size),max(size)]) plt.xlabel("Size [pixels]") plt.ylabel("Time [ms]") #plt.show() # save plot plt.savefig('media/plots/size-time.eps',format='eps', facecolor="white")
def create_validation_curve(estimator, X_train, y_train, data_name, clf_name, param_name, param_range, scorer): """Generates an validation/complexity curve for the ANN estimator, saves tabular results to CSV and saves a plot of the validation curve. Args: estimator (object): Target classifier. X_train (numpy.Array): Training features. y_train (numpy.Array): Training labels. data_name (str): Name of data set being tested. clf_name (str): Type of algorithm. param_name (dict): Name of parameter to be tested. param_range (dict): Range of parameter values to be tested. scorer (function): Scoring function. """ # generate validation curve results train_scores, test_scores = validation_curve(estimator, X_train, y_train, param_name=param_name, param_range=param_range, cv=5, scoring=scorer, n_jobs=1) # generate validation curve plot plt.figure(4) if param_name is 'SVMR__gamma' or param_name is 'MLP__alpha': plt.semilogx(param_range, np.mean(train_scores, axis=1), marker='.', color='b', label='Train Score') plt.semilogx(param_range, np.mean(test_scores, axis=1), marker='.', color='g', label='Cross-validation Score') else: plt.plot(param_range, np.mean(train_scores, axis=1), marker='.', color='b', label='Train Score') plt.plot(param_range, np.mean(test_scores, axis=1), marker='.', color='g', label='Cross-validation Score') plt.legend(loc='best') plt.title("Validation Curve with {} on {}".format(clf_name, data_name)) plt.grid(linestyle='dotted') plt.xlabel(param_name) plt.ylabel('Balanced Accuracy') plt.ylim((0, 1.1)) # save iteration curve plot as PNG plotdir = 'plots' plot_tgt = '{}/{}'.format(plotdir, clf_name) plotpath = get_abspath('{}_VC.png'.format(data_name), plot_tgt) plt.savefig(plotpath) plt.close()
k2, cl2, info2 = mixsyn(g, ws2, wu) # S and T for design 2 s2 = feedback(1, g * k2) t2 = feedback(g * k2, 1) # frequency response omega = np.logspace(-2, 2, 101) ws1mag, _, _ = ws1.frequency_response(omega) s1mag, _, _ = s1.frequency_response(omega) ws2mag, _, _ = ws2.frequency_response(omega) s2mag, _, _ = s2.frequency_response(omega) plt.figure(1) # text uses log-scaled absolute, but dB are probably more familiar to most control engineers plt.semilogx(omega, 20 * np.log10(s1mag.flat), label='$S_1$') plt.semilogx(omega, 20 * np.log10(s2mag.flat), label='$S_2$') # -1 in logspace is inverse plt.semilogx(omega, -20 * np.log10(ws1mag.flat), label='$1/w_{P1}$') plt.semilogx(omega, -20 * np.log10(ws2mag.flat), label='$1/w_{P2}$') plt.ylim([-80, 10]) plt.xlim([1e-2, 1e2]) plt.xlabel('freq [rad/s]') plt.ylabel('mag [dB]') plt.legend() plt.title('Sensitivity and sensitivity weighting frequency responses') # time response time = np.linspace(0, 3, 201) _, y1 = step_response(t1, time)
def visualize(self, plot_psd=True, save_psd=False, filename='psd.png', title='PSD', xlabel='frequency', xlabel_rot=0, ylabel='spectral level', fmin=0, fmax=32000, vmin=20, vmax=80, figsize=(16, 9), dpi=96): """ !!!!! This function will be moved into a different module in the future. The current documentation might not be accurate !!!!! Basic visualization of PSD estimate based on matplotlib. The function offers two options: Plot PSD in Python (plot_psd = True) and save PSD plot in directory (save_psd = True). PSDs are plotted in dB re 1µ Pa^2/Hz. plot_psd (bool): whether or not PSD is plotted using Python save_psd (bool): whether or not PSD plot is saved filename (str): directory where PSD plot is saved. Use ending ".png" or ".pdf" to save as PNG or PDF file. This value will be ignored if save_psd=False title (str): title of plot ylabel (str): label of vertical axis xlabel (str): label of horizontal axis xlabel_rot (float): rotation of xlabel. This is useful if xlabel are longer strings. fmin (float): minimum frequency (unit same as f) that is displayed fmax (float): maximum frequency (unit same as f) that is displayed vmin (float): minimum value (dB) of PSD. vmax (float): maximum value (dB) of PSD. figsize (tuple(int)): size of figure dpi (int): dots per inch """ import warnings raise warnings.warn('will be depricated in future. Please see ' 'ooipy.tools.ooiplotlib.plot_psd()') # set backend for plotting/saving: if not plot_psd: matplotlib.use('Agg') font = {'size': 22} matplotlib.rc('font', **font) if len(self.freq) != len(self.values): f = np.linspace(0, len(self.values) - 1, len(self.values)) else: f = self.freq fig, ax = plt.subplots(figsize=figsize, dpi=dpi) plt.semilogx(f, self.values) plt.ylabel(ylabel) plt.xlabel(xlabel) plt.xlim([fmin, fmax]) plt.ylim([vmin, vmax]) plt.xticks(rotation=xlabel_rot) plt.title(title) plt.grid(True) if save_psd: plt.savefig(filename, dpi=dpi, bbox_inches='tight') if plot_psd: plt.show() else: plt.close(fig)
axarr[2].set_title('$\\mathrm{LASSO},\ \\lambda=%.4f$' %(lmbda),fontsize=16) axarr[2].tick_params(labelsize=16) divider = make_axes_locatable(axarr[2]) cax = divider.append_axes("right", size="5%", pad=0.05) cbar=fig.colorbar(im, cax=cax) cbar.ax.set_yticklabels(np.arange(-1.0, 1.0+0.25, 0.25),fontsize=14) cbar.set_label('$J_{i,j}$',labelpad=-40, y=1.12,fontsize=16,rotation=0) fig.subplots_adjust(right=2.0) plt.show() # Plot our performance on both the training and test data plt.semilogx(lmbdas, train_errors_leastsq, 'b',label='Train (OLS)') plt.semilogx(lmbdas, test_errors_leastsq,'--b',label='Test (OLS)') plt.semilogx(lmbdas, train_errors_ridge,'r',label='Train (Ridge)')#,linewidth=1) plt.semilogx(lmbdas, test_errors_ridge,'--r',label='Test (Ridge)')#,linewidth=1) plt.semilogx(lmbdas, train_errors_lasso, 'g',label='Train (LASSO)') plt.semilogx(lmbdas, test_errors_lasso, '--g',label='Test (LASSO)') fig = plt.gcf() fig.set_size_inches(10.0, 6.0) #plt.vlines(alpha_optim, plt.ylim()[0], np.max(test_errors), color='k', # linewidth=3, label='Optimum on test') plt.legend(loc='lower left',fontsize=16) plt.ylim([-0.01, 1.01]) plt.xlim([min(lmbdas), max(lmbdas)]) plt.xlabel(r'$\lambda$',fontsize=16)
def plotRatio(self, stageN, stageD, xr=0, yr=0, label=1, title=1, bw=0, semilogx=1, verbose=0): ''' Plots the ratio of the ionization equilibria of two stages of a given element self.plotRatio(stageN, stageD) stages = sequence of ions to be plotted, neutral == 1, fully stripped == Z+1 stageN = numerator stageD = denominator xr = temperature range, yr = ion fraction range ''' ionN = util.zion2name(self.Z, stageN) ionD = util.zion2name(self.Z, stageD) ionNS = util.zion2spectroscopic(self.Z, stageN) ionDS = util.zion2spectroscopic(self.Z, stageD) atitle = 'ratio of %s to %s ' % (ionN, ionD) alabel = 'ratio of %s to %s ' % (ionNS, ionDS) print(atitle) if not hasattr(self, 'Ioneq'): print(' must first load or calculate an ionization equilibrium') return if bw: linestyle = ['k-', 'k--', 'k-.', 'k:'] plt.rcParams['font.size'] = 16. lw = 2 else: linestyle = ['b-', 'r--', 'g-.', 'm:'] plt.rcParams['font.size'] = 14. lw = 2 # goodTn = self.Ioneq[stageN - 1, :] > 0. goodTd = self.Ioneq[stageD - 1, :] > 0. realGoodT = np.logical_and(goodTn, goodTd) goodT = self.Temperature[realGoodT] goodR = self.Ioneq[stageN - 1, realGoodT] / self.Ioneq[stageD - 1, realGoodT] if not xr: xr = [goodT.min(), goodT.max()] if not yr: yr = [0.01, 1.1] xyr = list(xr) xyr.extend(list(yr)) # if semilogx: plt.semilogx(goodT, goodR, linestyle[0], lw=lw, label=alabel) else: plt.loglog(goodT, goodR, linestyle[0], lw=lw, label=alabel) plt.xlabel('Temperature (K)') plt.ylabel('Ratio') if title: atitle = 'CHIANTI Ionization Equilibrium' plt.title(atitle) plt.legend(loc='lower right') plt.tight_layout() self.Ratio = {'Temperature': goodT, 'Ratio': goodR, 'label': alabel}
def plot(self, stages=0, xr=0, yr=0, oplot=False, label=1, title=1, bw=0, semilogx=0, verbose=0): ''' Plots the ionization equilibria. self.plot(xr=None, yr=None, oplot=False) stages = sequence of ions to be plotted, neutral == 1, fully stripped == Z+1 xr = temperature range, yr = ion fraction range for overplotting: oplot="ioneqfilename" such as 'mazzotta' or if oplot=True or oplot=1 and a widget will come up so that a file can be selected. ''' if hasattr(self, 'Ioneq'): ioneq = getattr(self, 'Ioneq') else: print(' must first load or calculate and ionization equilibrium') return if bw: linestyle = ['k-', 'k--', 'k-.', 'k:'] plt.rcParams['font.size'] = 16. lw = 2 else: linestyle = ['b-', 'r--', 'g-.', 'm:'] plt.rcParams['font.size'] = 14. lw = 2 # if not stages: stages = range(1, self.Z + 2) elif min(stages) < 1 or max(stages) > self.Z + 1: stages = range(1, self.Z + 2) # spectroscopic notation if not xr: xr = [self.Temperature.min(), self.Temperature.max()] if not yr: yr = [0.01, 1.1] xyr = list(xr) xyr.extend(list(yr)) # iz = stages[0] if semilogx: plt.semilogx(self.Temperature, ioneq[iz - 1], linestyle[0], lw=lw) else: plt.loglog(self.Temperature, ioneq[iz - 1], linestyle[0], lw=lw) if label: idx = self.Ioneq[iz - 1] == self.Ioneq[iz - 1].max() if idx.sum() > 1: jdx = np.arange(len(idx)) idx = int(jdx[idx].max()) ann = const.Ionstage[iz - 1] plt.annotate(ann, [self.Temperature[idx], 0.7 * ioneq[iz - 1, idx]], ha='center') for iz in stages[1:]: if semilogx: plt.semilogx(self.Temperature, ioneq[iz - 1], linestyle[0], lw=lw) else: plt.loglog(self.Temperature, ioneq[iz - 1], linestyle[0], lw=lw) if label: idx = ioneq[iz - 1] == ioneq[iz - 1].max() if idx.sum() > 1: jdx = np.arange(len(idx)) idx = int(jdx[idx].mean()) ann = const.Ionstage[iz - 1] plt.annotate(ann, [self.Temperature[idx], 0.7 * ioneq[iz - 1, idx]], ha='center') plt.xlabel('Temperature (K)') plt.ylabel('Ion Fraction') atitle = 'Chianti Ionization Equilibrium for ' + const.El[ self.Z - 1].capitalize() # if oplot: if isinstance(oplot, int): result = io.ioneqRead(ioneqName='') # print('keys = ', result.keys() if result != False: atitle += ' & ' + result['ioneqname'].replace( '.ioneq', '') atitle += ' ' + linestyle[0] for iz in stages: plt.plot(result['ioneqTemperature'], result['ioneqAll'][self.Z - 1, iz - 1], linestyle[1], lw=lw) elif type(oplot) == type('string'): atitle += ' & ' + oplot result = io.ioneqRead(ioneqname=oplot) if result != False: for iz in stages: plt.plot(result['ioneqTemperature'], result['ioneqAll'][self.Z - 1, iz - 1], linestyle[1], lw=lw) elif type(oplot) == type([]): for iplot in range(len(oplot)): result = io.ioneqRead(ioneqname=oplot[iplot]) # print 'keys = ', result.keys() if result != False: atitle += ' & ' + oplot[iplot] + ' ' + linestyle[iplot % 3] for iz in stages: plt.plot(result['ioneqTemperature'], result['ioneqAll'][self.Z - 1, iz - 1], linestyle[1], lw=lw) else: print(' oplot file not understood %s' % (oplot)) if title: plt.title(atitle) plt.tight_layout() plt.axis(xyr)
if options.format == None: plt.show() # Showing graph else: plt.savefig(filename + "_power." + options.format) # Saving graph plt.clf() # Cleaning current plot. gain = 10 * np.log10(padc / pdac) # Calculating Gain in dB # -3 dB is an important number, isn't it? y_ticks = np.array([ -40, -36, -33, -30, -26, -23, -20, -16, -13, -10, -6, -3, -1, 0, 1, 3, 6, 10, 13, 16, 20, 23, 26, 30, 33, 36, 40 ]) plt.semilogx(f, gain) plt.yticks(y_ticks[(y_ticks < (gain.max() + 1)) & (y_ticks > (gain.min() - 1))]) plt.grid(b=True) plt.grid(b=True, which='minor') plt.xlabel('Frequency (Hz)') plt.ylabel('Gain (dB)') if options.format == None: plt.show() else: plt.savefig(filename + "_gain." + options.format) plt.clf() # Samples plt.plot(3.3 * dac[-1000:-1] / 4096, 'x')
], name=model_name ) optimizer = SGD(lr=1e-8, momentum=0.9) model.compile(loss="mse", optimizer=optimizer, metrics=['mae']) #%% # Training epochs = 100 lr_schedule = LearningRateScheduler(lambda epoch: 1e-8 * 10**(epoch / 20)) history_lrs = model.fit(dataset, epochs=epochs, callbacks=[lr_schedule, tensorboard_callback], verbose=1) #%% # Visualizing Learning Rates plt.semilogx(history_lrs.history['lr'], history_lrs.history["loss"]) plt.axis([1e-8, 1e-3, 0, 300]) #%% # Repeat with the minimum learning rate #%% # Learning Rate Scheduler dataset = windowed_dataset(x_train, window_size, batch_size, shuffle_buffer_size) model_name = f'seq_rnn-1010' model = Sequential(layers=[ Conv1D(filters=32, kernel_size=5, strides=1, padding="causal", activation="relu", input_shape=[None, 1]), Bidirectional(LSTM(32, return_sequences=True)), Bidirectional(LSTM(32)), Dense(1),
for x0 in xx0: t, x = sol.ode1(system, x0, t0, tf, h) if x0 >= 0: T_x0[i] = np.argmax(np.abs(x) < 1.5e-4) * h i += 1 plt.figure(num=1) plt.plot(t, x[0], color=0 * np.ones(3)) # Trajectories plt.figure(num=1) plt.ylim(-3, 5) plt.xlim(0, 1.2) plt.xlabel('$t$', fontsize=18) plt.ylabel('$x(t,x_0)$', fontsize=18) plt.axvline(x=1, ymin=-1, ymax=2, linestyle='dashed', color=0.3 * np.ones(3)) plt.grid() plt.savefig('figures/basic.eps', bbox_inches='tight', format='eps', dpi=1500) # Settling-time function figure plt.figure(num=2) plt.semilogx(xx0, T_x0, 'k', lw=2) plt.grid() plt.xlabel('|$x_0$|', fontsize=18) plt.ylabel('$T(x_0)$', fontsize=18) plt.axhline(y=1, xmin=-1, xmax=2, linestyle='dashed', color=0.3 * np.ones(3)) plt.ylim(0, 1.2) plt.savefig('figures/settling_basic.eps', bbox_inches='tight', format='eps', dpi=1500)
Dx.append(stokeslaw(l1, l0)) Dy.append(stokeslaw(l0, l1)) Dxy.append(stokeslaw(l1, l1)) import matplotlib.pyplot as plt D = {"r": Dx, "z": Dy, "rz": Dxy} for s in D: fname = "confinement_%s.eps" % s plt.plot(lrange, D[s], 's-') plt.xlabel("distance of confining wall compared to particle radius") plt.ylabel("dimensionless diffusion constant D/D_bulk") plt.savefig(fname, bbox_inches='tight') plt.show() fname = "confinement_%s_semilogx.eps" % s plt.semilogx(lrange, D[s], 's-') plt.xlabel("distance of confining wall compared to particle radius") plt.ylabel("dimensionless diffusion constant D/D_bulk") plt.savefig(fname, bbox_inches='tight') plt.show() fname = "confinement_%s_loglog.eps" % s plt.loglog(lrange, D[s], 's-') plt.xlabel("distance of confining wall compared to particle radius") plt.ylabel("dimensionless diffusion constant D/D_bulk") plt.savefig(fname, bbox_inches='tight') plt.show() #plt.legend(loc='lower right')
speedW = [] for i in range(len(N)): s = timeS[0] / timeS[i] speedS.append(s) w = timeW[0] / timeW[i] speedW.append(w) # print(speedW) # print(speedS) # # # Plotting fig = plt.figure() plt.semilogx(N, speedS, 'black', label='Strong scaling', marker='o', markerfacecolor='red', markersize=4) plt.semilogx(N, speedW, 'blue', label='Weak scaling', marker='o', markerfacecolor='black', markersize=4) # # plt.semilogy(N, speedS, 'black', label='Strong scaling', # # marker='o', markerfacecolor='red', markersize=4) # # plt.semilogy(N, speedW, 'blue', label='Weak scaling', # # marker='o', markerfacecolor='red', markersize=4) # # ## Theoritical error of MC: err is proportional to Itr ^ (-1/2) ###
secondtimes) * np.transpose(bigfai) * t_train_use bigfai_val = a1.func_x_times(x_val, 2) y_val = np.transpose(w) * np.transpose(bigfai_val) t_val_error = t_val - np.transpose(y_val) rms_val_error = np.sqrt(np.mean(np.square(t_val_error))) validation_err += rms_val_error validation_err_avg[lamda] = validation_err / 10 regression_reg(0, 2) # replace lambda=0 with lambda=10^-5 for plotting purpose. regression_reg(0.01, 2) regression_reg(0.1, 2) regression_reg(1, 2) regression_reg(10, 2) regression_reg(100, 2) regression_reg(1000, 2) regression_reg(10000, 2) label = sorted(validation_err_avg.keys()) error = [] for key in label: error.append(validation_err_avg[key]) print(error) plt.semilogx(label, error) plt.ylabel('Average RMS') plt.legend(['Average Validation error']) plt.show()
for ws in weight_scales: best_train_accs.append(max(solvers_ws[ws].train_acc_history)) bn_best_train_accs.append(max(bn_solvers_ws[ws].train_acc_history)) best_val_accs.append(max(solvers_ws[ws].val_acc_history)) bn_best_val_accs.append(max(bn_solvers_ws[ws].val_acc_history)) final_train_loss.append(np.mean(solvers_ws[ws].loss_history[-100:])) bn_final_train_loss.append(np.mean(bn_solvers_ws[ws].loss_history[-100:])) plt.subplot(3, 1, 1) plt.title('Best val accuracy vs weight initialization scale') plt.xlabel('Weight initialization scale') plt.ylabel('Best val accuracy') plt.semilogx(weight_scales, best_val_accs, '-o', label='baseline') plt.semilogx(weight_scales, bn_best_val_accs, '-o', label='batchnorm') plt.legend(ncol=2, loc='lower right') plt.subplot(3, 1, 2) plt.title('Best train accuracy vs weight initialization scale') plt.xlabel('Weight initialization scale') plt.ylabel('Best training accuracy') plt.semilogx(weight_scales, best_train_accs, '-o', label='baseline') plt.semilogx(weight_scales, bn_best_train_accs, '-o', label='batchnorm') plt.legend() plt.subplot(3, 1, 3) plt.title('Final training loss vs weight initialization scale') plt.xlabel('Weight initialization scale') plt.ylabel('Final training loss')
ax.set_ylabel('$y$') ax.set_zlabel('$u$') fig.colorbar(surf, shrink=0.75, orientation='horizontal', label='$u$') ax = fig.add_subplot(gs[1], projection='3d') surf = ax.plot_surface(x_test[:, :, 0], y_test[:, :, 0], np.abs(u_analytic[:, :, -1] - u_pred[:, :, -1]), vmin=0., cmap='hot_r') ax.set_xlabel('$x$') ax.set_ylabel('$y$') ax.set_zlabel('$|u-u^*|$', labelpad=10) cbar = fig.colorbar(surf, shrink=0.75, orientation='horizontal', label='$|u-u^*|$') cbar.formatter.set_powerlimits((0, 0)) # cbar.ax.set_xticklabels(np.linspace(0, 0.0012, 5), rotation=90, ) plt.savefig('membrane_inv-results.pdf', dpi=300) fig = plt.figure(figsize=(4, 3)) plt.semilogx(h.history['parameter_epochs'], np.concatenate(h.history['parameter_c']).flatten()) plt.xlabel('epochs') plt.ylabel('$c$') plt.title('$c^* = 1.0$') plt.subplots_adjust(0.2, 0.15, 0.8, 0.85) plt.savefig('membrane_inv-resylts2.pdf', dpi=300)
def plot_exptime_vs_limiting_mag(exptimes, limiting_mags, filter_names=["J", "H", "Ks"], colors="bgrcymk", mmin=22, mmax=29, legend_loc=3, marker="+"): """ Plots exposure time versus limiting magnitudes Parameters ---------- exptimes : list, array [s] Exposure times corresponding to the signal-to-noise values limiting_mags : array, list of array [mag] Limiting magnitudes for one, or more, filters for the given exposure times Dimensions are (1, n) for a single filter, or (m, n) for m filters filter_names : list A list of m filters. See :func:`simcado.optics.get_filter_set` colors : list The colours to use for dots in the plot mmin, mmax : float The minimum and maximum magnitudes for the y axis marker : str The matplotlib scatter marker key legend_loc : int Location of the legend. If ``None`` is passed, no legend is plotted """ import matplotlib.pyplot as plt if len(np.shape(limiting_mags)) == 1: limiting_mags = [limiting_mags] if filter_names is None: filter_names = [ "Filter " + str(i) for i in range(np.shape(limiting_mags)[0]) ] elif isinstance(filter_names, str): filter_names = [filter_names] * np.shape(limiting_mags)[0] exptimes = np.array(exptimes) fig = plt.gcf() #ax = fig.add_axes([a_left, a_bottom, ax_width, ax_height]) ax1 = fig.add_axes([0, 0, 1, 1]) for mag, clr, filt in zip(limiting_mags, colors, filter_names): plt.plot(exptimes / 3600, mag, clr + marker, label=filt) if legend_loc is not None: plt.legend(loc=legend_loc, scatterpoints=1) plt.xlabel("Exposure time [hours]") plt.ylabel("Limiting Magnitudes") plt.xlim(np.min(exptimes / 3600) - 0.1, np.max(exptimes / 3600) + 0.1) plt.ylim(22, 31) plt.grid("on") ax2 = fig.add_axes([0.5, 0.15, 0.45, 0.35]) for mag, clr in zip(limiting_mags, colors): plt.plot(exptimes, mag, clr + marker) plt.plot((60 * 1, 60 * 1), (mmin, mmax), "k:") plt.text(60 * 1 - 5, mmin + 0.5, "1 min", horizontalalignment="right") plt.plot((60 * 4, 60 * 4), (mmin, mmax), "k:") plt.text(60 * 4 - 5, mmin + 0.5, "4 min", horizontalalignment="right") plt.plot((60 * 15, 60 * 15), (mmin, mmax), "k:") plt.text(60 * 15 - 5, mmin + 0.5, "15 min", horizontalalignment="right") plt.xlim(10, 1800) plt.ylim(mmin, mmax) plt.semilogx() plt.xlabel("Exposure time [sec]")
history = model.fit(dataset, epochs=100, callbacks=[lr_schedule]) return history # In[89]: # Run the training with dynamic LR lr_history = adjust_learning_rate(train_set) # In[91]: plt.semilogx(lr_history.history["lr"], lr_history.history["loss"]) plt.axis([1e-4, 10, 0, 10]) # ## Compiling the model # Now that you have trained the model while varying the learning rate, it is time to do the actual training that will be used to forecast the time series. For this complete the `create_model` function below. # # Notice that you are reusing the architecture you defined in the `create_uncompiled_model` earlier. Now you only need to compile this model using the appropriate loss, optimizer (and learning rate). # # Hints: # # - The training should be really quick so if you notice that each epoch is taking more than a few seconds, consider trying a different architecture. # # # - If after the first epoch you get an output like this: loss: nan - mae: nan it is very likely that your network is suffering from exploding gradients. This is a common problem if you used SGD as optimizer and set a learning rate that is too high. If you encounter this problem consider lowering the learning rate or using Adam with the default learning rate.
learning_rate=3, max_iter=100, cv=3, verbose=True) print("gl_glm: ", gl_glm) print("glm: ", glm) ########################################################## # Fit models gl_glm.fit(Xtrain, ytrain) glm.fit(Xtrain, ytrain) ########################################################## # Visualize model scores on test set plt.figure() plt.semilogx(gl_glm.reg_lambda, gl_glm.scores_, 'go-') plt.semilogx(glm.reg_lambda, glm.scores_, 'ro--') plt.legend(['Group Lasso', 'Lasso'], frameon=False, loc='best') plt.xlabel('$\lambda$') plt.ylabel('pseudo-$R^2$') plt.tick_params(axis='y', right='off') plt.tick_params(axis='x', top='off') ax = plt.gca() ax.spines['top'].set_visible(False) ax.spines['right'].set_visible(False) plt.show()
[2, 3]) Ebeam = col.beam_atte[0].E_ref dens = col.beam_atte[0].densities T = col.beam_atte[0].temperature lifetime = np.zeros((T.shape[0], dens.shape[0])) for i, t in enumerate(T): lifetime[i, :] = col.get_lifetime(dens, t, t, Ebeam, 1.0, 0) plt.figure() plt.contourf(dens, T, lifetime) plt.colorbar() plt.show() 'small check for the emission and the beam stopping coefficient' ne = np.linspace(np.min(dens), np.max(dens), 1000) t_ref = T[4] at = col.get_attenutation(Ebeam, ne, 1.0, t_ref, 0) em = col.get_emission(Ebeam, ne, 1.0, t_ref, 0) if ((at < 0) | (em < 0)).any(): print np.sum(at < 0), at[at < 0] print np.sum(em < 0), em[em < 0] plt.figure() plt.semilogx(ne, em < 0, label='emission') plt.semilogx(ne, at < 0, label='attenuation') plt.semilogx(dens, dens > 0, 'x') plt.legend() plt.figure() plt.semilogx(ne, em) plt.show() raise NameError('Error in the interpolation or in the ADAS file')
def plot_lr_schedule(history): plt.figure(figsize=(10, 6)) plt.semilogx(history.history["lr"], history.history["loss"]) plt.axis([1e-8, 1e-4, 0, 30]) plt.show()
#Defining the transfer function T(s) #Since the transfer function T(s) is (s+2)/(s^4 + 12s^3 + 47s^2 + 60s) s1 = signal.lti([1 * k, 2 * k], [1, 12, 47, 60, 0]) w, mag, phase = signal.bode(s1) #Wpc -phase crossover freq. using builtin functions s = ml.tf('s') gm, pm, Wpc, Wgc = ml.margin( (k * s + 2 * k) / (s**4 + 12 * s**3 + 47 * s**2 + 60 * s)) #Verifying Gain Margin of G(s) gm = 20 * log10(gm) print('Gain Margin of G(s) =', gm, ', when K is substituted') plt.subplot(2, 1, 1) plt.semilogx(w, mag, 'b', label='_nolegend_') # Bode Magnitude plot plt.plot(Wpc, -38, 'o', label='_nolegend_') plt.xlabel('Frequency(rad/s)') plt.ylabel('Mag') plt.axhline(y=-RN, xmin=0, xmax=Wpc, color='b', linestyle='dashed') plt.axvline(x=Wpc, ymin=0, ymax=0.56, color='k', linestyle='dashed') plt.text(1.0, -60, '({}, {})'.format(round(Wpc, 2), -38)) plt.legend(['-38 dB line'], loc='lower left') plt.grid() plt.subplot(2, 1, 2) plt.semilogx(w, phase, label='_nolegend_') #Bode Pahse plot plt.plot(Wpc, -180, 'o', label='_nolegend_') plt.subplot(2, 1, 2) plt.xlabel('Frequency(rad/s)') plt.ylabel('Phase(deg)')
plt.plot(y_array, dsdxdy, label="CalculationValues", color="blue", lw=2) spllist = np.power( 10., glam.grideval(result, [ np.array([np.log10(q2)]), np.array([np.log10(x)]), np.log10(y_array) ])[0]) #print spllist[0] plt.plot(y_array, spllist[0], label="InterValues", color="red", lw=2, ls="dashed") plt.semilogx() plt.title(r"$Q2 = " + str(q2) + "," + " x = " + str(x) + "$") plt.legend(loc="lower left") plt.xlabel("y") plt.ylabel("dsigma/dxdy") plt.savefig("./plots/dsdxdy_" + pdfname + "_" + neutype + "_" + str(q2) + "_" + str(x) + "_" + variation + ".png") print "Saved: ./plots/dsdxdy_" + pdfname + "_" + neutype + "_" + str( q2) + "_" + str(x) + "_" + variation + ".png" plt.close(fig)
f2 = np.convolve(f, np.ones((N, )) / N, mode='same') pref = np.convolve(pref, np.ones((N, )) / N, mode='same') minfre = .16 maxfre = .3 scale = np.mean(pref[(f2 >= minfre) & (f2 <= maxfre)]) - np.mean( ps[0][(f >= minfre) & (f <= maxfre)]) print(scale) scaleHF = np.mean(pm[(f >= 10.) & (f <= 11.)]) - np.mean( pmHF[(fHF >= 10.) & (fHF <= 11.)]) numb = 20 fig = plt.figure(1, figsize=(12, 12)) plt.semilogx(f2[numb:-numb], pref[numb:-numb], c='.5', label='STS-2 Reference') plt.semilogx(f[numb:-numb], pm[numb:-numb] + scale, color='b', label='Mean Nodal Noise') plt.semilogx(f[numb:-numb], nm[numb:-numb] + scale, color='r', label='Mean Nodal Incoherent Noise') plt.semilogx(fHF[numb:-numb], pmHF[numb:-numb] + scale + scaleHF, color='b') plt.semilogx(fHF[numb:-numb], nmHF[numb:-numb] + scale + scaleHF, color='r') plt.semilogx(1. / NLNMper, NLNMpower, linewidth=2., color='k') plt.semilogx(1. / NHNMper, NHNMpower, linewidth=2.,
tf.keras.layers.Bidirectional( tf.keras.layers.LSTM(32, return_sequences=True)), tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32)), tf.keras.layers.Dense(1), tf.keras.layers.Lambda(lambda x: x * 10.0) ]) lr_schedule = tf.keras.callbacks.LearningRateScheduler( lambda epoch: 1e-8 * 10**(epoch / 20)) optimizer = tf.keras.optimizers.SGD(lr=1e-8, momentum=0.9) model.compile(loss=tf.keras.losses.Huber(), optimizer=optimizer, metrics=["mae"]) history = model.fit(dataset, epochs=100, callbacks=[lr_schedule]) plt.semilogx(history.history["lr"], history.history["loss"]) plt.axis([1e-8, 1e-4, 0, 30]) tf.keras.backend.clear_session() tf.random.set_seed(51) np.random.seed(51) tf.keras.backend.clear_session() dataset = windowed_dataset(x_train, window_size, batch_size, shuffle_buffer_size) model = tf.keras.models.Sequential([ tf.keras.layers.Lambda(lambda x: tf.expand_dims(x, axis=-1), input_shape=[None]), tf.keras.layers.Bidirectional( tf.keras.layers.LSTM(32, return_sequences=True)),
#if using termux import subprocess import shlex #end if gain = [50] poles=[0,-2,-4,-6] zeros=[-3,-5] system = signal.lti(zeros,poles,gain) w , mag, phase = signal.bode(system) plt.subplot(2,1,1) plt.xlabel('Frequency(rad/sec)') # Bode Magnitude plot plt.ylabel('Mag') plt.title('Magnitude plot') plt.semilogx(w, mag,'b') plt.axhline(y = 0,xmin=0,xmax= 0.68,color = 'r',linestyle='dashed') plt.axvline(x = 6.43,ymax=0.4,color='k',linestyle='dashed') plt.plot(6.43,0,'o') plt.text(6.45,2, '({}, {})'.format(6.43,0)) plt.axhline(y = -7,xmin=0,xmax= 0.72,color = 'r',linestyle='dashed') plt.axvline(x = 10.1,ymax=0.38,color='k',linestyle='dashed') plt.plot(10.1,-7,'o') plt.text(10.4,-7.4, '({}, {})'.format(10.1,-7)) plt.grid() plt.subplots_adjust(hspace=0.5) plt.subplot(2,1,2) plt.xlabel('Frequency(rad/s)') # Bode phase plot plt.ylabel('Phase(deg)')
nonlinear = False with open(filename, 'r') as logfile: for line in logfile: words = line.split() if words[0] == 'Elements' and words[1] == 'QoI': use = True continue if words[0] == 'nonlinear': nonlinear = words[-1] == 'True' if use: elements.append(int(words[0])) qois.append(float(words[1])) qois = np.array(qois) # init_diff = np.zeros(len(qois)) if qois_old is None else qois[0] - qois_old[0] # qois_old = qois # plt.semilogx(elements, qois - init_diff, label='Nonlinear SWEs' if nonlinear else 'Linear SWEs') plt.semilogx(elements, qois, linestyle='--', marker='o', label='Nonlinear SWEs' if nonlinear else 'Linear SWEs') plt.xlabel("Element count") plt.ylabel(r"Quantity of interest, $J(\mathbf{u},\eta)$") plt.legend() date = datetime.date.today() date = '{:d}-{:d}-{:d}'.format(date.year, date.month, date.day) di = create_directory( os.path.join(di, '{:s}-runs-{:s}'.format(date, '-'.join([r for r in runs])))) plt.savefig(os.path.join(di, 'qoi_convergence.png'))
def satview(h): a = np.pi * 0.5 - np.arcsin(R / (R + h)) o = 4 * np.pi * np.sin(a * 0.5)**2 return o * R**2 mansee = satview(H) # ca 72 km**2 Hiss = 370.0e3 # ISS, Hubble Hsun = 800.0e3 # sun-syncro satellites, science obs, Iridium satellites (flares in the sky) Hmeo = 20.2e6 # GNSS Hgeo = 35.786e6 # Hbm = 29.0e6 # distance for Blue marble Hma = 405.4e6 # Moon apogee Hl1 = 1.4811e11 # Lagrangian point L1 Earth-Sun system H = np.logspace(np.log10(1000), np.log10(Hbm), 1000) plt.figure() plt.plot(H, satview(H) / Se) plt.vlines([Hiss, Hsun, Hmeo, Hbm], ymin=0.0, ymax=0.5) plt.grid() H = np.logspace(np.log10(10000), np.log10(Hl1), 1000) plt.figure() plt.semilogx(H, satview(H) / Se) plt.vlines([Hiss, Hsun, Hmeo, Hgeo, Hbm, Hma, Hl1], ymin=0.0, ymax=0.5) plt.grid()
plt.figure() train_scores_mean = np.mean(train_scores, axis=1) train_scores_std = np.std(train_scores, axis=1) test_scores_mean = np.mean(test_scores, axis=1) test_scores_std = np.std(test_scores, axis=1) plt.title('Validation Curve with SVM') plt.xlabel('$\gamma$ (gamma)') plt.ylabel('Score') plt.ylim(0.0, 1.1) lw = 2 plt.semilogx(param_range, train_scores_mean, label='Training score', color='darkorange', lw=lw) plt.fill_between(param_range, train_scores_mean - train_scores_std, train_scores_mean + train_scores_std, alpha=0.2, color='darkorange', lw=lw) plt.semilogx(param_range, test_scores_mean, label='Cross-validation score', color='navy', lw=lw)
]) # In[21]: plt.plot(fbz_count[:, :], 'k', lw=1) plt.plot(fbz_n33_count[:, :], 'r', lw=1) # In[22]: fig, ax_arr = plt.subplots(1, 2, sharey=True) ax_arr[1].semilogx(gammas[::], fbz_mean[:, :], 'k', lw=1) ax_arr[0].semilogx(n33_gammas[::], fbz_n33_mean[:, :], 'k', lw=1) # In[23]: plt.semilogx(gammas[::], fbz_mean[:, :], 'b', lw=1) plt.semilogx(n33_gammas[::], fbz_n33_mean[:, :], 'k', lw=1) # In[24]: fig, ax_arr = plt.subplots(1, 2, sharey=True) ax_arr[1].semilogx(omegas[::], fbz_mean[:, :], 'k', lw=1) ax_arr[0].semilogx(n33_omegas[::], fbz_n33_mean[:, :], 'k', lw=1) plt.ylim(-20, 20) # In[25]: plt.semilogx(omegas[::], fbz_mean[:, :], 'b', lw=1) plt.semilogx(n33_omegas[::], fbz_n33_mean[:, :], 'k', lw=1) # In[26]:
cv=10, scoring="accuracy", n_jobs=1) train_scores_mean = np.mean(train_scores, axis=1) train_scores_std = np.std(train_scores, axis=1) test_scores_mean = np.mean(test_scores, axis=1) test_scores_std = np.std(test_scores, axis=1) plt.title("Validation Curve with SVM") plt.xlabel("$\gamma$") plt.ylabel("Score") plt.ylim(0.0, 1.1) lw = 2 plt.semilogx(param_range, train_scores_mean, label="Training score", color="darkorange", lw=lw) plt.fill_between(param_range, train_scores_mean - train_scores_std, train_scores_mean + train_scores_std, alpha=0.2, color="darkorange", lw=lw) plt.semilogx(param_range, test_scores_mean, label="Cross-validation score", color="navy", lw=lw) plt.fill_between(param_range, test_scores_mean - test_scores_std,
plt.loglog(flops[GPU2_22], GPUdat[GPU2_22, 6], 'r+') plt.loglog(flops[GPU4_22], GPUdat[GPU4_22, 6], 'b+') plt.loglog(flops[GPU6_22], GPUdat[GPU6_22, 6], 'g+') plt.xlabel('Problem FLOPs') plt.ylabel('Computational time') plt.legend(('2 GPUs nonblocking', '4 GPUs nonblocking',\ '6 GPUs nonblocking', '2 GPUs', '4 GPUs', '6 GPUs')) plt.savefig('../report/fig/flops_time.eps', format='eps') msize = GPUdat[:, 2] * GPUdat[:, 3] * GPUdat[:, 4] * 8 * 3 * 1e-6 #/GPUdat[:,1] #msize=GPUdat[:,2]*GPUdat[:,3]/(GPUdat[:,4]/GPUdat[:,1]) plt.figure() plt.grid() plt.semilogx(msize[GPU2_23], fps[GPU2_23], 'rx-') plt.semilogx(msize[GPU4_23], fps[GPU4_23], 'bx-') plt.semilogx(msize[GPU6_23], fps[GPU6_23], 'gx-') plt.xlabel('Memory footprint [MB]') plt.ylabel('FLOPs/s') plt.legend(('2 GPUs', '4 GPUs', '6 GPUs'), loc='upper left') plt.ylim((0, 1e+12)) plt.savefig('../report/fig/m_fps_23.eps', format='eps') plt.figure() plt.grid() plt.semilogx(msize[GPU2_22], fps[GPU2_22], 'rx-') plt.semilogx(msize[GPU4_22], fps[GPU4_22], 'bx-') plt.semilogx(msize[GPU6_22], fps[GPU6_22], 'gx-') plt.xlabel('Memory footprint [MB]') plt.ylabel('FLOPs/s')