def plot_filter_characteristics(self): w, h = freqz(self.freq_filter.num, self.freq_filter.denom) plt.figure(1) plt.subplot(2,1,1) plt.hold(True) powa = plt.plot((self.filter_parameters.sample_rate*0.5/pi)*w, abs(h),'b-', label = 'Char. amplitudowa') plt.title('Charakterystyki filtru') plt.xlabel('Czestotliwosc [Hz]') plt.ylabel('Amplituda') plt.twinx(ax=None) angles = unwrap(angle(h)) plt.znie = plot((self.filter_parameters.sample_rate*0.5/pi)*w,angles, 'g-', label = 'Char. fazowa') plt.ylabel('Faza') plt.grid() tekst = powa + znie wybierz = [l.get_label() for l in tekst] plt.legend(tekst, wybierz, loc='best') ######################################################################################################################## plt.subplot(2,1,2) w2, gd = group_delay((num, denom)) plt.plot((sample_rate*0.5/pi)*w2, gd) plt.grid() plt.xlabel('Czestotliwosc [Hz]') plt.ylabel('Opoznienie grupowe [probki]') plt.title('Opoznienie grupowe filtru') plt.show()
def log_plot(): start = int(np.floor(np.log(min(median)) / np.log(10))) + 3 end = int(np.ceil(np.log(max(median)) / np.log(10))) + 3 xs = [] ticks = [] for i in range(start, end + 1): xs.append(10 ** (i - 3)) if i % 3 == 0: ticks.append('{}s'.format(prefix[i / 3])) else: ticks.append(str(10 ** (i % 3))) plt.barh(pos, median, align='center', height=0.25, left=1e-3, color=bar_color, lw=0) plt.errorbar(median, pos, ecolor=error_bar_color, fmt=None, xerr=err) plt.grid(True) plt.xlabel('Time') plt.xlim(min(xs), max(xs)) plt.xscale('log') plt.xticks(xs, ticks) plt.ylim(ymax=size) plt.yticks(pos, language) plt.twinx() plt.ylim(ymax=size) plt.yticks(pos, relative) plt.savefig('plots/{}.png'.format(pid), bbox_inches='tight') plt.clf()
def timeseries(bs, dt=1): if not hasattr(bs, '__iter__'): bs = [bs,] nrow = len(bs) for (i, b) in enumerate(bs): p = params(b) plt.subplot(nrow, 1, 1+i) v = pop212(b).sum(axis=1) # stack over channels nt = len(v) dt = min(dt, nt) nt = nt - np.fmod(nt, dt) # fit time segments after decimation v = v[:nt].reshape((nt/dt, -1)).sum(axis=1) # clip to multiple of dt and stack t = p.dtvec[:nt].reshape((-1, dt)).mean(axis=1) + p.T/2. amp = np.abs(v) phase = np.angle(v) plt.plot(t, amp, 'b.-') plt.ylim(0, plt.ylim()[1]) plt.gca().set_yticklabels([]) plt.twinx() plt.plot(t, phase, 'r.-') plt.ylim(-np.pi, np.pi) plt.gca().set_yticklabels([]) putil.rmgaps(1e6, 2.0) plt.xlim(0, p.T) plt.gca().add_artist(AnchoredText(p.baseline, loc=1, frameon=False, borderpad=0)) plt.setp(plt.gcf(), figwidth=8, figheight=2+nrow) plt.tight_layout() plt.subplots_adjust(hspace=0)
def plt_twin( axis, tick0=None, tick=None ) : ''' Add x-top or y-right axis axis: ['x' | 'y'] tick0: Must between [0, 1] ''' if (str(axis).lower() not in ['x', 'y']) : Raise(Warning, "axis='"+str(axis)+"' not in ['x', 'y']. Do nothing !") axis = str(axis).lower() #-------------------------------------------------- if (tick0 is not None and tick is not None) : tick0 = npfmt(tick0, float) if (tick0.min()<0 or tick0.max()>1) : Raise(Warning, 'tick0.(min,max)=(%.1f, %.1f) out of [0, 1]. Do nothing !' % (tick0.min(), tick0.max())) else : if (axis == 'x') : plt.twiny() plt.xticks(tick0, tick) elif (axis == 'y') : plt.twinx() plt.yticks(tick0, tick) #-------------------------------------------------- elif (tick0 is None and tick is None) : if (axis == 'x') : plt.tick_params(axis='x', which='both', labeltop='on', labelbottom='on') elif (axis == 'y') : plt.tick_params(axis='y', which='both', labelleft='on', labelright='on') #-------------------------------------------------- else : Raise(Warning, 'tick0, tick must both ==None or !=None, now one is None but the other is not. Do nothing !')
def pcs(self): self.pesobj = PES.PES(self.X,self.Y,self.S,self.D,self.lb.flatten(),self.ub.flatten(),self.para['kindex'],self.para['mprior'],self.para['sprior'],DH_SAMPLES=self.para['DH_SAMPLES'], DM_SAMPLES=self.para['DM_SAMPLES'], DM_SUPPORT=self.para['DM_SUPPORT'],DM_SLICELCBPARA=self.para['DM_SLICELCBPARA'],mode=self.para['SUPPORT_MODE']) xmin = self.reccomend() plt.figure(1) plt.plot(xmin[0],xmin[1],'r.') print xmin plt.figure(2) plt.subplot(4,1,1) ns = 6000 sup = sp.linspace(-1,1,ns) for i in xrange(2): X = sp.vstack([xmin for k in xrange(ns)]) print X.shape for j in xrange(ns): X[j,i] = sup[j] [m,v] = self.pesobj.G.infer_diag_post(X,[[sp.NaN]]*ns) s = sp.sqrt(v) plt.subplot(4,1,2*i+1) plt.fill_between(sup,(m-2*s).flatten(),(m+2*s).flatten(), facecolor='lightblue',edgecolor='lightblue') plt.plot(sup,m.flatten()) [m,v] = self.pesobj.G.infer_diag_post(X,[[i]]*ns) s = sp.sqrt(v) plt.subplot(4,1,2*i+2) plt.fill_between(sup,(m-2*s).flatten(),(m+2*s).flatten(), facecolor='lightblue',edgecolor='lightblue') plt.plot(sup,m.flatten(),'r') p = sp.exp(-0.5*(m**2)/v) plt.twinx().plot(sup,p.flatten(),'g') return
def main(): # switch the commented lines here to alternate between CV testing and making kaggle submission x_train, x_test, y_train, y_test = load_data_cv('data/train_32.npy') #x_train, y_train, x_test = load_data_test('data/train_32.npy', 'data/test_32.npy') model = build_model() print("Starting training") # batch iterator with 300 epochs train_loss = [] valid_loss = [] valid_acc = [] for i in range(300): loss = batch_iterator(x_train, y_train, 128, model) train_loss.append(loss) valid_avg = model.evaluate(x_test, y_test, show_accuracy = True, verbose = 0) valid_loss.append(valid_avg[0]) valid_acc.append(valid_avg[1]) print 'epoch:', i, 'train loss:', np.round(loss, decimals = 4), 'valid loss:', np.round(valid_avg[0], decimals = 4), 'valid acc:', np.round(valid_avg[1], decimals = 4) train_loss = np.array(train_loss) valid_loss = np.array(valid_loss) valid_acc = np.array(valid_acc) sns.set_style("whitegrid") pyplot.plot(train_loss, linewidth = 3, label = 'train loss') pyplot.plot(valid_loss, linewidth = 3, label = 'valid loss') pyplot.legend(loc = 2) pyplot.ylim([0,4.5]) pyplot.twinx() pyplot.plot(valid_acc, linewidth = 3, label = 'valid accuracy', color = 'r') pyplot.grid() pyplot.ylim([0,1]) pyplot.legend(loc = 1) pyplot.show()
def fidelity_vs_power(folder='', x_axis_par='par_ro_Ex_power'): if folder == '': folder = os.getcwd() allfiles = os.listdir(folder) fidfiles = [f for f in allfiles if ('totalfid' in f and '.dat' in f)] x_axis = [] #in this case powers maxfid = [] maxfid_t = [] for f in fidfiles: fn, ext = os.path.splitext(f) idx = int(fn[fn.find('+_')+2:]) basepath = os.path.join(folder, PREFIX+'-'+str(idx)) parfile = basepath+'_'+PARAMS_SUFFIX+'.dat' x_axis.append(loadtxt(parfile)[get_param_column(parfile,x_axis_par)]*1e9) #pwr in nW fiddat = loadtxt(f) maxidx = argmax(fiddat[1,:]) maxfid.append(fiddat[1,maxidx]) maxfid_t.append(fiddat[0,maxidx]) fig = plt.figure() plt.plot(x_axis, maxfid, 'ro', label='max F') plt.xlabel('P [nW]') plt.ylabel('max. F') plt.legend() plt.twinx() plt.plot(x_axis, maxfid_t, 'bo') plt.ylabel('best ro-time') plt.savefig('fidelity_vs_power.png')
def laserPlot(filenameLst): ''' Plot the temporal and spectral profile of a mode-locked fiber laser simulation ''' nbrPlots = len(filenameLst) for i in arange(len(filenameLst)): results = load(filenameLst[i]) t = results['t'] nt = results['nt'] T = results['T'] archivePass = results['archivePass'] nu_inst_out3 = results['nu_inst_out3'] nu_inst_out4 = results['nu_inst_out4'] spectre_out = results['spectre_out'] wavelength = results['wavelength'] # Graph plt.figure(figsize=(12,9)) ax3 = plt.subplot(221) plt.plot(t, pow(abs(archivePass[0]),2), color="black") plt.ylabel("$|u(z,T)|^2$ [W]") plt.xlabel("$T/T_0$") plt.xlim([-T/2,T/2]) plt.grid(True) ax4 = plt.twinx() plt.plot(t[0:nt-1], nu_inst_out3) plt.ylabel("Chirp") ax4.yaxis.tick_right() plt.ylim([-1.5,1.5]) ax5 = plt.subplot(223) plt.semilogy(t, pow(abs(archivePass[0]),2), color="black") plt.ylabel("$|u(z,T)|^2$ [dBm]") plt.xlabel("$T/T_0$") plt.xlim([-T/2,T/2]) plt.grid(True) ax4 = plt.twinx() plt.plot(t[0:nt-1], nu_inst_out3) plt.ylabel("Chirp") ax4.yaxis.tick_right() plt.ylim([-1.5,1.5]) ax7 = plt.subplot(222) plt.plot(wavelength, spectre_out, color="black") plt.xlabel("Wavelength [nm]") plt.grid(True) ax8 = plt.subplot(224) plt.semilogy(wavelength, spectre_out, color="black") plt.xlabel("$T/T_0$") plt.xlabel("Wavelength [nm]") plt.grid(True) plt.show()
def makeFig(): plt.title('recycle') plt.plot(xArray, '-ro', label='paper') plt.legend(loc='upper left') plt2=plt.twinx() plt2.plot(yArray, 'b^-', label='plastic') plt2.legend(loc='upper center') plt3=plt.twinx() plt3.plot(zArray, 'gD-', label='can') plt3.legend(loc='lower left')
def plot_label_by_success(setup_name, school, context_name=None, term_type=None, legend=True, linetype='-', show_data_size=True, set_order=None): data = load_ratings_with_contexts() if set_order is not None: data = data[data['practice_set_order'] == set_order] data = data[(data['experiment_setup_name'] == setup_name)] if context_name is not None: data = data[data['context_name'] == context_name] if term_type is not None: data = data[data['term_type'] == term_type] if school is not None: school_usage = load_school_usage().reset_index().rename(columns={'ip_address': 'school', 'user_id': 'user'}) data = pandas.merge(data, school_usage, on='user', how='inner') data = data[data['school'] == school] data = data[data['error_rate'].apply(lambda x: x % 10 == 0)] def _apply(group): result = [] for label in group['label'].unique(): mean = binomial_confidence_mean(group['label'] == label) result.append({ 'label': label, 'learners': 100 * mean[0], 'learners_min': 100 * mean[1][0], 'learners_max': 100 * mean[1][1], }) return pandas.DataFrame(result) to_plot = data.groupby(['experiment_setup_name', 'error_rate']).apply(_apply).reset_index().sort_values(by=['label', 'error_rate']) for i, (label, label_data) in enumerate(to_plot.groupby('label')): plt.plot( label_data['error_rate'], label_data['learners'], linetype, label=label.split('-')[-1], color=output.palette()[i], marker='.', markersize=20 ) plt.fill_between( label_data['error_rate'], label_data['learners_min'], label_data['learners_max'], color=output.palette()[i], alpha=0.35 ) if legend: plt.legend(ncol=3, loc='upper left', frameon=True) plt.ylabel('Label (%)') plt.xlabel('Real error rate') plt.gca().xaxis.grid(True) plt.gca().yaxis.grid(True) if show_data_size: plt.twinx() size = data.groupby('error_rate').apply(len).reset_index().rename(columns={0: 'size'}) plt.plot(size['error_rate'], size['size'], '.-', color='gray') plt.ylabel('Data size') plt.ylim(0, 70)
def trialPlot(dm, soa, _show=show, err=True, minSmp=200, suffix='', padding=0, diff=True): """ A pupil-trace plot for the full trial epoch. Arguments: dm -- A DataMatrix. soa -- The SOA to select. Keyword arguments: _show -- Indicates whether the plot should be shown. (default=True) err -- Indicates whether error bars should be drawn. (default=True) suffix -- A suffix to identify the trace. (default='') padding -- A padding time to be added to the traceLen. (default=0) diff -- Indicates whether the difference trace should be plotted as well. (default=True) """ assert(soa in dm.unique('soa')) if _show: Plot.new(size=Plot.ws) plt.title('SOA: %d ms' % (soa+55)) plt.axhline(1, linestyle='--', color='black') dm = dm.select('soa == %d' % soa) # Determine the trace length and create the trace plot traceLen = soa + 105 + padding traceParams = trialParams.copy() traceParams['traceLen'] = traceLen tracePlot(dm, traceParams=traceParams, err=err, suffix='.%d%s' % (soa, \ suffix), minSmp=minSmp) # Cue plt.axvspan(0, cueDur, color=blue[1], alpha=.2) # Target. Take into account to cue duration in determining the target onset. targetOnset = soa+55 plt.axvspan(targetOnset, targetOnset+targetDur, color=blue[1], alpha=.2) plt.xlim(0, 2550) plt.legend(frameon=False) plt.xlabel('Time since cue onset (ms)') plt.ylabel('Pupil size (norm.)') plt.yticks([1,1.025, 1.05]) plt.xticks(range(0, 2501, 500)) if diff: plt.ylim(.92, 1.07) plt.axhline(diffY, linestyle='--', color='black') plt.twinx() plt.tick_params(axis="y") plt.ylim(.92, 1.07) plt.yticks([.925,.95, .975], [-.025, 0, .025]) else: plt.ylim(.98, 1.07) if _show: Plot.save('trialPlot.%d' % soa, 'trialPlot', show=show)
def fidelity_vs_power(folder='',sweep_param='Ex_RO_amplitude'): if folder == '': folder = os.getcwd() allfiles = os.listdir(folder) fidfiles = [f for f in allfiles if ('totalfid' in f and '.dat' in f)] pow = [] maxfid = [] maxfid_t = [] for f in fidfiles: fn, ext = os.path.splitext(f) idx = int(fn[fn.find('+_')+2:])-1 print idx if idx < 10: SUFFIX = '-00'+str(idx) elif idx == 10: SUFFIX = '-0'+str(idx) elif idx < 100: SUFFIX = '-0'+str(idx) basepath = os.path.join(folder, PREFIX+SUFFIX) parfile = basepath+'_parameters_dict.npz' param_dict=load(parfile) #pow.append(loadtxt(parfile)[get_param_column(parfile,'par_ro_Ex_power')]*1e9) #pow.append(int(idx/2)*1.) pow.append(param_dict[sweep_param]) param_dict.close fiddat = loadtxt(f) maxidx = argmax(fiddat[1,:]) maxfid.append(fiddat[1,maxidx]) maxfid_t.append(fiddat[0,maxidx]) #fiddat.close() fig = plt.figure() plt.plot(pow, maxfid, 'ro', label='max F') plt.xlabel('P [nW]') plt.ylabel('max. F') plt.ylim(ymax=1.2*max(maxfid)) plt.title('Maximum SSRO Fidelity and Optimal readout time vs' + sweep_param) plt.text(0.01*(max(pow)+min(pow)),1.15*max(maxfid),folder,fontsize='x-small') plt.legend() plt.twinx() plt.plot(pow, maxfid_t, 'bo') plt.ylabel('best ro-time') plt.ylim(ymax=1.2*max(maxfid_t)) plt.savefig('fidelity_vs_power.png')
def sampleExponentials(self, n_samples = 1000): la = np.load("results/fitDistLog.npy") x = np.linspace(0, 1, 100) av = np.average(la[:, :2], axis=0) cov = np.cov(la[:, :2].T) s = np.random.multivariate_normal(av, cov, size=n_samples) vals = s[:, 0]*np.exp(np.outer(x, s[:, 1])) print vals.shape bins, _, _ = self.getBinnedData(2, 100) '''for i in xrange(100): if len(bins[i]) != 0: plt.hist(bins[i], bins=50, alpha=0.6, normed=True) plt.hist(vals[i], bins=50, alpha=0.6, color='r', normed=True) plt.savefig("results/comparefullhist{0:03d}.pdf".format(i)) plt.clf()''' plt.subplot(231) hist, xedges, yedges = np.histogram2d(la[:, 0], la[:, 1], bins=20, normed=True) plt.imshow(hist.T, interpolation = 'nearest', cmap=cm.Blues, aspect = 'auto', extent=[np.min(xedges), np.max(xedges), np.min(yedges), np.max(yedges)], origin='lower') plt.subplot(232) samples = np.random.multivariate_normal(av, cov, size=10*n_samples) hist_sp, xedges_sp, yedges_sp = np.histogram2d(samples[ :, 0], samples[ :, 1], bins=50, normed=True) plt.imshow(hist_sp.T, interpolation = 'bicubic', cmap=cm.Reds, aspect = 'auto', extent=[np.min(xedges_sp), np.max(xedges_sp), np.min(yedges_sp), np.max(yedges_sp)], origin='lower') plt.subplot(233) plt.pcolor(np.linspace(np.min(xedges), np.max(xedges), len(xedges)), np.linspace(np.min(yedges), np.max(yedges), len(yedges)), hist.T, alpha=0.8, cmap=cm.Blues) plt.pcolor(np.linspace(np.min(xedges_sp), np.max(xedges_sp), len(xedges_sp)), np.linspace(np.min(yedges_sp), np.max(yedges_sp), len(yedges_sp)), hist_sp.T, alpha=0.5, cmap=cm.Reds) plt.subplot(234) plt.hist2d(la[:, 0], la[:, 1], bins=20, cmap=cm.Blues) plt.subplot(235) _, bx, _ = plt.hist(la[:, 1], 20, alpha=0.6, normed=True) plt.hist(samples[:, 1], 20, color='r', alpha=0.6, normed=True) xp = np.linspace(np.min(bx), np.max(bx), 100) p = scipy.stats.norm.pdf(xp, loc=av[1], scale=np.sqrt(cov[1,1])) plt.plot(xp, p) plt.subplot(236) nx, bx, _ = plt.hist(la[:, 0], 20, alpha=0.6, normed=True) plt.hist(samples[:, 0], 20, color='r', alpha=0.6, normed=True) xp = np.linspace(np.min(bx), np.max(bx), 100) p = scipy.stats.norm.pdf(xp, loc=av[0], scale=np.sqrt(cov[0,0])) plt.plot(xp, p) plt.twinx() plt.plot(bx[1:]-np.diff(bx), np.cumsum(nx)*np.diff(bx), color='g') plt.savefig("results/comparehistdist.pdf") plt.clf()
def makeFig(): #Create a function that makes the desired plot gs = gridspec.GridSpec(3, 3) #gridspec is created 3x3 #First plot fig 1 #Plot 1 plt.subplot(gs[0, :]) #subplot position atributes plt.ylim([-30,50]) #Set y min and max values plt.title('Temperatura em Graus C') #Plot the title plt.grid(True) #Turn on the grid plt.ylabel('Temp-1 c') #Set ylabels plt.plot(tempF, 'ro-', label='temperatura em graus') #plot the temperature plt.legend(loc='upper left') #plot the legend plt2=plt.twinx() #Create a second y axis plt.ylim(-30,50) #Set limits of second y axis- adjust to readings you are getting plt2.plot(tempF2, 'b^-', label='Temp-2 c') #plot temperature array plt2.set_ylabel('Temp-2 c') #label second y axis plt2.ticklabel_format(useOffset=False) #Force matplotlib to NOT autoscale y axis plt2.legend(loc='upper right') #plot the legend #second plot same figure (same window) #Plot 2 plt.subplot(gs[1, :]) #subplot position attributes plt.ylim([0,100]) #Set y min and max values plt.title('Humidade do Ar em Percentagem') #Plot the title plt.grid(True) #Turn on the grid plt.ylabel('Himidade-1 %') #Set ylabels plt.plot(humF1, 'ro-', label='Humidade') #plot the temperature plt.legend(loc='upper left') #plot the legend plt2=plt.twinx() #Create a second y axis plt.ylim(0,100) #Set limits of second y axis- adjust to readings you are getting plt2.plot(humF2, 'b^-', label='Humidade-2 %') #plot temperature array plt2.set_ylabel('Humidade-2 %') #label second y axis plt2.ticklabel_format(useOffset=False) #Force matplotlib to NOT autoscale y axis plt2.legend(loc='upper right') #plot the legend #Third plot same figure (same window) #Plot 3 plt.subplot(gs[-1,0]) #subplot position atributes plt.ylim([0,100]) #Set y min and max values plt.title('Humidade do solo') #Plot the title plt.grid(True) #Turn on the grid plt.ylabel('Himidade %') #Set ylabels plt.plot(moist, 'ro-', label='Humidade') #plot the temperature plt.legend(loc='upper left') #plot the legend #Fourth plot same figure (same window) #Plot 4 plt.subplot(gs[-1,-1]) #subplot position atributes plt.ylim([0,2000]) #Set y min and max values plt.title('Luminosidade') #Plot the title plt.grid(True) #Turn on the grid plt.ylabel('Luminosidade (lux)') #Set ylabels plt.plot(lum, 'ro-', label='Luminosidade') #plot the temperature plt.legend(loc='upper left') #plot the legend
def plotsigma(self,emit=2.5e-6/7000*0.938,deltap=1.1e-4,**nargs): self.sigx =sqrt(self.betx*emit)*1000 self.sigy =sqrt(self.bety*emit)*1000 self.sigdx=self.dx*deltap*1000 self.plot('sigx sigy sigdx',**nargs) ya,yb=pl.ylim() pl.twinx() bmax=max(self.betx.max(),self.bety.max()) rng=range(0,int(_n.ceil(_n.log10(bmax)))+1) bval=_n.array([n*10**dd for dd in rng for n in [1,2,5] ]) bval=bval[bval<bmax] pl.ylim(ya,yb) self._plot=_p.gcf() return t
def payload_loss_figure(self): ps = [] rs = [] rs2 = [] Omegas = [i * 0.001 for i in range(1, 201)] last_p = 0 for Omega in Omegas: self.udp.Omega = Omega p, r = self.udp.get_payload_size() if p != last_p: print "Omega=%s, p=%s, r=%s" % (Omega, p, r) last_p = p ps.append(p) rs.append(r) r2 = self.udp.get_ratio_lower(p=4096) rs2.append(r2 / r) plt.clf() plt.cla() l, = plt.plot(Omegas, ps) plt.legend([l], ["Optimal\nPayload Size"], loc="upper left", prop={"size": 18}) # print ps # plt.ylim(ymin=0.0, ymax=1) plt.ticklabel_format(style="sci", axis="x", scilimits=(3, 3)) plt.ticklabel_format(style="sci", axis="y", scilimits=(-2, 0)) plt.grid(True) plt.xlabel("Packet Loss Rate") plt.ylabel("Optimal Payload Size per Chunk") plt.twinx() # l1, = plt.plot(Omegas, rs, "g") # l2, = plt.plot(Omegas, rs2, "r") # plt.ylabel("Max Goodput-to-Throughput Ratio") # plt.legend([l1, l2], ["Max G2T Ratio", "Ratio of 4096-to-LB"], loc="upper right", prop={'size':18}) # l1, = plt.plot(Omegas, rs, "g") # l2, = plt.plot(Omegas, rs2, "r") plt.ylabel("Max Goodput-to-Throughput Ratio") plt.legend([l1], ["Max G2T Ratio"], loc="upper right", prop={"size": 18}) plt.title("UDP: $\Delta$=%s, M=%s" % (self.udp.Delta, self.udp.M)) name = "payload-loss-M%s-Delta%s" % (self.udp.M, self.udp.Delta) name.replace(".", "") plt.savefig(self.udp.out_dir + "/" + name + ".pdf") print "%s.pdf ends" % (name)
def agdd_plots(nplots, iplot, tbase, tmax, t_range, temp, agdd): """This function does the AGDD plots in a nplots vertical stack of plots. iplot is the current plot (from top to bottom, starting at 1), tbase and tmax are the values used for AGDD calculations. t_range is a temporal range (usually DoY) and temp and AGDD are extracted 2m temperature and AGDD""" plt.subplot(nplots, 1, iplot) # Put a grey area for the AGDD calculation bounds plt.axhspan(tbase, tmax, xmin=0, xmax=366, color="0.9") # Plot temperature plt.plot(t_range, temp, "-r", label="Tm") plt.ylabel("Mean Temp [degC]") plt.grid(True) plt.twinx() plt.plot(t_range, agdd, "-g", label="AGDD") plt.ylabel("AGDD [degC]")
def ex_twinplot(self, X, Y, **kwargs): # go_with_x() # ax = gca() # If type is tuple, use secondary verticle axis, otherwise plot multiple values on same scale if type(Y) == tuple: if len(Y)>2: raise Exception, "twinx plots only takes two arguments" else: for i in range(len(Y)): self.ex_plot(X, Y[i], **kwargs) twinx() else: for i in range(len(Y)): self.ex_plot(X, Y[i], **kwargs)
def plot_data(lines, save_loc = ["plot_output.pdf",], **kwargs): '''Plots a series of data lines Each line is (x_list, y_list, properties_dict) ''' fig = pyplot.figure() #Set up legend area if kwargs.get('legend_outside'): ax = fig.add_axes([0.1, 0.1, 0.55, 0.8]) else: ax = fig.add_subplot(111) if kwargs.get('plot_title'): pyplot.title(kwargs.get('plot_title')) legend_text = []; legend_lines = [] #Plot passed in points. for line in lines: title = line[2].pop('title', None) title_on_plot = line[2].pop('title_on_plot', False) plot_function = ax.loglog if kwargs.get('log_plot', None) else ax.plot plotted = plot_function(line[0],line[1],**(line[2] if len(line) > 2 else {})) if title and not title_on_plot: legend_lines.append(plotted) legend_text.append(title) for t in kwargs.get('text_labels', []): ax.text(**t) if kwargs.get('axis_v'): ax.axis(kwargs.get('axis_v')) elif kwargs.get('zero_yaxis'): ax.set_ylim((0.0, ax.get_ylim()[1])) if kwargs.get('x_tick_freq'): ax.xaxis.set_major_locator(MultipleLocator(kwargs.get('x_tick_freq'))) if kwargs.get('y_tick_freq'): ax.yaxis.set_major_locator(MultipleLocator(kwargs.get('y_tick_freq'))) if kwargs.get('x_tick_func'): ax.xaxis.set_major_formatter(FuncFormatter(kwargs.get('x_tick_func'))) if kwargs.get('y_tick_func'): ax.yaxis.set_major_formatter(FuncFormatter(kwargs.get('y_tick_func'))) if legend_lines: if kwargs.get('legend_outside'): fig.legend(legend_lines, legend_text, loc = kwargs.get('legend_placement', 'best'), numpoints=1) else: ax.legend(legend_lines, legend_text, loc = kwargs.get('legend_placement', 'best'), numpoints=1) if kwargs.get('x_title'): ax.set_xlabel(kwargs.get('x_title')) if kwargs.get('y_title'): ax.set_ylabel(kwargs.get('y_title')) #Draw a second scale if kwargs.get('y2_transform') is not None: ax2 = pyplot.twinx(ax = ax) ax2.yaxis.set_view_interval(kwargs.get('y2_transform')(ax.yaxis.get_view_interval()[0]), kwargs.get('y2_transform')(ax.yaxis.get_view_interval()[1])) if kwargs.get('y2_title'): ax2.yaxis.set_label_text(kwargs.get('y2_title')) if save_loc is not None: for l in save_loc: pyplot.savefig(l, format=os.path.splitext(l)[1][1:]) if kwargs.get('show_plot'): show()
def plot_mfc_budget(mfc_budget, index, year, legend=True, legend_kw={'fontsize' : 9, 'loc' : 'upper left', 'handlelength' : 2.5}, dashes=[6, 2], netprecip=False): ts = mfc_budget.sel(year=year) ind = index.sel(year=year) days = ts['day'].values styles = {'PRECTOT' : {'color' : 'k', 'linestyle' : '--', 'dashes' : dashes}, 'EVAP' : {'color' : 'k'}, 'MFC' : {'color' : 'k', 'linewidth' : 2}, 'dw/dt' : {'color' : '0.7', 'linewidth' : 2}} if netprecip: styles['P-E'] = {'color' : 'b', 'linewidth' : 2} for nm in styles: plt.plot(days, ts[nm], label=nm, **styles[nm]) plt.axvline(ind['onset'], color='k') plt.axvline(ind['retreat'], color='k') plt.xlabel('Day of Year') plt.ylabel('mm/day') ax1 = plt.gca() ax2 = plt.twinx() plt.sca(ax2) plt.plot(days, ind['tseries'], 'r', alpha=0.6, linewidth=2, label='CMFC') atm.fmt_axlabels('y', 'mm', color='r', alpha=0.6) if legend: atm.legend_2ax(ax1, ax2, **legend_kw) return ax1, ax2
def hist_plot_two_y(m, n, p, mv, nv, pv, filename): x = np.arange(0,len(m)) ax = plt.subplot(111) common_params = dict(bins=len(m), range=(0,len(m)), normed=False) patterns = ('//', '', '\\') _, _, patches = plt.hist((x,x,x), weights=(m,n,p), \ label=["Autocorrelation", "HOS", "PCS-based HOS"], **common_params) for patch,pattern in zip(patches, patterns): [k.set_hatch(pattern) for k in patch] ax2 = plt.twinx() ax2.plot(map(lambda i:i+0.5, x), np.array(mv)/np.array(m), label="Autocorrelation", linestyle=':', color='b', marker='v', linewidth=1.5) ax2.plot(map(lambda i:i+0.5, x), np.array(nv)/np.array(n), label="HOS", linestyle='-.', color='g', marker='^', linewidth=1.5) ax2.plot(map(lambda i:i+0.5, x), np.array(pv)/np.array(p), label="PCS-based HOS", linestyle='-', color='r', marker='s', linewidth=1.5) formatter = FuncFormatter(to_percent) ax2.yaxis.set_major_formatter(formatter) ax2.yaxis.label.set_fontsize(15) ax2.set_ylabel("Ratio between variance and amplitude", labelpad=10) names = ["lag#0","lag#1","lag#2","lag#3","lag#4","lag#5","lag#6"] ax.xaxis.label.set_fontsize(15) ax.yaxis.label.set_fontsize(15) ax.set_xticks([k+0.5 for k in range(7)]) #ax.set_xticklabels(names,rotation=30, rotation_mode="anchor", ha="right") ax.set_xticklabels(names) ax.set_ylabel("Amplitude of cumulants", labelpad=10) ax.set_xlabel("Lags of the model", labelpad=10) plt.tight_layout() plt.grid(axis='y') plt.legend(loc=9, fancybox=True, shadow=True) plt.savefig(filename, format='pdf') plt.show()
def assess_flux_stability(samplename='Glassy_Carbon'): ip = get_ipython() f = plt.figure() ax1 = f.add_subplot(1, 1, 1) plt.xlabel('Date of exposure') plt.ylabel('Beam flux (photon/sec), continuous lines') ax2 = plt.twinx() plt.ylabel('Vacuum pressure (mbar), dotted lines') plt.title('Beam flux stability') samplenames = sorted([sn_ for sn_ in ip.user_ns['_headers_sample'] if samplename in sn_]) linestyles = ['b', 'g', 'r', 'c', 'm', 'y', 'k'] lines = [] for sn, ls in zip(samplenames, linestyles): print(sn) heds = ip.user_ns['_headers_sample'][sn] allheds = [] for k in heds.keys(): allheds.extend(heds[k]) allheds = sorted(allheds, key=lambda x: x.fsn) flux = np.array([float(h.flux) for h in allheds]) dates = [h.date for h in allheds] lines.extend(ax1.plot(dates, flux, ls + 'o', label='Flux (%s)' % sn)) vacuums = np.array([float(h.vacuum) for h in allheds]) lines.extend(ax2.plot(dates, vacuums, ls + 's', label='Vacuum (%s)' % sn, lw=2)) print(' Measurement duration: %.2f h' % ((dates[-1] - dates[0]).total_seconds() / 3600.)) print(' Mean flux: ', flux.mean(), '+/-', flux.std(), 'photons/sec') print(' RMS variation of flux: ', flux.std() / flux.mean() * 100, '%') print(' P-P variation of flux: ', flux.ptp() / flux.mean() * 100, '%') ax1.legend(lines, [l.get_label() for l in lines], loc='best') plt.show()
def graph(fil): heap, time , free = np.loadtxt(fil, delimiter=',', unpack=True) fig,ax1 = plt.subplots(dpi=120, figsize=(7,7)) ax2 = plt.twinx() ax1.set_ylabel("Allocation time ($ms$)",color = 'blue') ax1.set_xlabel("Initial heap size ($MB$)") ax2.set_ylabel("Free space on heap ($MB$)",color = 'green') ax2.set_xlabel("Initial heap size ($MB$)") p1,= ax1.plot(heap,time, label='Time taken to allocate large array') p2,= ax2.plot(heap,free , label='Free space on heap' ,color = 'green') plt.title('Scala Fragmentation tolerance') from matplotlib.font_manager import FontProperties fontP = FontProperties() fontP.set_size('small') lines =[p1,p2] plt.legend(lines, [l.get_label() for l in lines],prop = fontP ,loc =9) name = fil.split('.')[0] name = name +".png" plt.savefig(name)
def hist(nndist, **kwds): if 'output' in kwds: import matplotlib matplotlib.use('Agg') from matplotlib import pyplot as plt # handle formatting keywords linewidth = kwds.get('linewidth', 3) #plt.rc('text', usetex=True) plt.rc('font', family='serif') n, bins, patches = plt.hist(nndist, normed=True, bins=100) width = bins[1] - bins[0] ax1 = plt.gca() ax2 = plt.twinx() ax2.plot(bins[:-1], width*np.cumsum(n), 'r-', linewidth=linewidth) ax2.set_ylim(top=1.0) tics = ax1.get_yticks(); ax1.set_yticks(tics[1:]) tics = ax2.get_yticks(); ax2.set_yticks(tics[1:]) ax1.set_xlabel(r"d ($\mu$m)") ax1.set_ylabel(r"PDF") ax2.set_ylabel(r"CDF", color='r') for tl in ax2.get_yticklabels(): tl.set_color('r') # check scalar descriptors median_dist = np.median(nndist) ax1.axvline(median_dist, color='gray', linewidth=linewidth) # handle keywords if 'title' in kwds: plt.title(kwds['title']) if 'output' in kwds: plt.draw() plt.savefig(kwds['output']) else: plt.show()
def plotter (kind, experimental, steps): #print "maxdist_data :", len(maxdist_data) #print "experimental :", len(experimental) data_axes = ['8B','16B','32B','64B','128B','256B', '512B', '1KB', '2KB', '4KB', '8KB', '16KB','32KB','64KB','128KB','256KB', '512KB', '1MB', '2MB', '4MB', '8MB', '16MB','32MB'] model1 = plt.plot(maxdist_data, model_no_congestion(steps) , '--gD', label="Analytical model (link)") model1 = plt.plot(maxdist_data, model_node(steps) , '--bD', label="Analytical model (node)") #model2 = plt.plot(maxdist_data, model_with_congestion(steps) , '--yD', label="Analytical model (with congestion)") line = plt.plot(maxdist_data, experimental , '--r*', label=kind) plt.xticks(maxdist_data, data_axes, rotation=45) plt.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3, ncol=2, mode="expand", borderaxespad=0.5) #duplicate_err = plt.plot(maxdist_data, err(experimental, [no_congestion_model(d, steps) for d in maxdist_data]) , '-bs', label="Error %") plt.ylabel("Time to completion in us (log2 scale)") plt.xlabel("Data per Halo exchange in Bytes(log2 scale)") err_plot = plt.twinx() rects1 = plt.bar(maxdist_data, err(experimental, [node_model(d, steps) for d in maxdist_data]), 0.35, alpha=0.2, color='r', label='Error %') #err_plot.plot(maxdist_data, err(experimental, [no_congestion_model(d, steps) for d in maxdist_data]) , '-bs', label="Error %") #err_plot.plot(maxdist_data, err(experimental, [congestion_model(d, steps) for d in maxdist_data]) , 'b-') #err_plot.plot(maxdist_data, err(linear_data, [no_congestion_model(d, steps) for d in maxdist_data]) , 'y-') plt.title('Time to complete halo exchange - 512 Nodes, RPN 16, 5D application matrix') err_plot.set_ylabel('Error %') plt.show()
def plot_error_time(self): '''Plot the speed and follow error on one figure, using two axes.''' for times, follow, speed, _ in self.each_condition('error'): ax = pl.gca() n = np.sqrt(len(follow)) m = follow.mean(axis=0) e = follow.std(axis=0) / n lf = ax.plot(times, m, color='b') ax.fill_between(times, m - e, m + e, color='b', alpha=0.3, lw=0) ax.set_ylabel('Follow Error (m)') ax.set_ylim(*eval(self.opts.follow)) ax.set_xlim(times[0], times[-1]) ax = pl.twinx() m = speed.mean(axis=0) e = speed.std(axis=0) / n ls = ax.plot(times, m, color='g') ax.fill_between(times, m - e, m + e, color='g', alpha=0.3, lw=0) ax.set_ylabel('Speed Error (m/s)') ax.set_ylim(*eval(self.opts.speed)) ax.set_xlim(times[0], times[-1]) ax.set_xlabel('Time (s)') pl.grid(True) pl.legend((lf, ls), ('Follow', 'Speed'), loc='lower right')
def get(self): db = self.application.database epoc=datetime(2016,1,9) t = list() vbat = list() vsol = list() temp = list() for r in db.records.find(): if r.has_key("content"): c=json.loads(r["content"]) t.append((r["timestamp"]-epoc).total_seconds()/3600.0) vbat.append(c["vbat"]) vsol.append(c["vsol"]) temp.append(c["temperature"]) fig = plt.figure() ax1 = fig.add_subplot(111) l1 = ax1.plot(t, vsol, '-', linewidth=1, label="Vsol (mV)") l2 = ax1.plot(t, vbat, '-', linewidth=1, label="Vbat (mV)") ax2 = plt.twinx() l3 = ax2.plot(t, temp, '-', linewidth=1, label=u"Temperature (°C)", color="r") ax1.legend(loc=0) ax2.legend() buf = io.BytesIO() plt.savefig(buf, format='png') self.set_header("Content-Type", "image/png") self.write(buf.getvalue()) buf.close()
def plot_DE_results( OFE_budgets, Fmin_values, N_values, Cr_values, F_values ): pyplot.figure() pyplot.subplot(1,2,1) _plot_pareto_front( OFE_budgets, Fmin_values ) pyplot.subplot(1,2,2) line_Cr = pyplot.semilogx(OFE_budgets, Cr_values, 'b^')[0] line_F = pyplot.semilogx(OFE_budgets, F_values, 'rx')[0] pyplot.ylabel('Cr, F') pyplot.twinx() line_N = pyplot.semilogx(OFE_budgets, N_values, 'go')[0] pyplot.ylim( 0, max(N_values)*1.1) pyplot.ylabel('N') pyplot.legend([line_Cr,line_F,line_N], ['Cr','F','N'], loc='upper center') pyplot.xlim(min(OFE_budgets),max(OFE_budgets)) pyplot.xlabel('OFE budget') pyplot.title('Optimal CPVs for different OFE budgets')
def plot_CMD_CDD_diff(CMD_file_name, CCD_file_name, init_dis, CCD_start_num=0, CMD_start_num=0, factor=10000): ''' ��ȡ����λ�ú�CCDʵ�ʲ��λ�������ļ�������CCD�ļ��е����ݽ��н�ȡ��Ȼ�����߶Աȣ��õ���� CMD_file_name��CMD�������ļ� CCD_file_name��CCD�������ļ� init_dis��CCD�ɼ�ʱ�����ڵļ�� CCD_start_num��CCD�ɼ���������Ч���ݵ���ʼ��ַ����һ�����ݵ��start_numΪ0 CMD_start_num��PMAC������������Ч���ݵ���ʼ��ַ,��һ�����ݵ��start_numΪ0 factor��CCD���ݲɼ���λ��PMAC�ĵ�λת�����ӣ���1mmת��0.1umΪ10000. ''' CMD_data = get_data_from_file(CMD_file_name)[CMD_start_num:-1] # CMD_data = CCD_data_process(CMD_file_name, init_dis=0, start_num=CMD_start_num, factor=1) CCD_data = CCD_data_process(CCD_file_name, init_dis, CCD_start_num, len(CMD_data)) CCD_line, = plt.plot(CCD_data, label='CCD') CMD_line, = plt.plot(CMD_data, label='CMD') plt.xlabel(r't/442us') plt.ylabel(r'y/cts') print CCD_data[-1] - CMD_data[-1] print len(CCD_data), len(CMD_data) logging.warning("dd") par2 = plt.twinx() fe_line, = par2.plot(CMD_data - CCD_data, label='fe') par2.set_ylabel('following error') fe_line.set_color('red') plt.legend([CCD_line, CMD_line, fe_line], ["CCD", "CMD", "fe"]) plt.grid() plt.show() pass
def plotVectors(json, coincidence=0, name="", minTime=30, maxTime=1700, labels=False): delims = readDelims() macAddresses = {} json["packets"].apply(lambda row: addPacket(row, macAddresses), axis=1) sum = np.zeros(json["last"], dtype=np.int) for val in macAddresses.values(): diff = val[1] - val[0] if ((diff > minTime) and (diff < maxTime) and (val[2] >= coincidence)): sum[val[0]: val[1]] += 1 plot.xlabel('Seconds since start') plot.ylabel('Devices', color='b') plot.step(range(int(json["last"])), sum.tolist()) actual = [stop['actual'] for stop in delims] stopx = [stop['start'] for stop in delims] ax2 = plot.twinx() ax2.step(stopx, actual, 'r', where="post") (t1.set_color for t1 in ax2.get_yticklabels()) ax2.set_ylabel('Riders', color='r') plot.ylim(0, 30) plot.xlim(0, json["last"]) if(labels): for stop in delims: annotate(stop["code"], stop["start"], stop["actual"], 10, 10) makeWidePlot("bus", "vectors") plot.show()
rec=rec, FS = FS, filename_h5 = spec_data) model_results['run_model'].append('spec2m_simple') # plotting section # what will be plottet nr_p = plot_rates + plot_adapt + plot_input fig = plt.figure(); pidx = 1 if plot_input: ax_mu = fig.add_subplot(nr_p, 1, pidx) plt.plot(t_ext, mu_ext_orig, color = 'k', lw=1.5) if filter_mean else 0 line_mu_final = plt.plot(t_ext, ext_input0[0], color = 'm', lw=1.5, label='$\mu_\mathrm{final}$') plt.ylabel('$\mu_{ext}$ [mV/ms]', fontsize=15) ax_sig = plt.twinx() plt.plot(t_ext, sigma_ext_orig, color = 'g', lw=1.5) if filter_std else 0 line_sig_final = plt.plot(t_ext, ext_input0[1], color = 'b', lw=1.5, label='$\sigma_\mathrm{final}$') plt.ylabel('$\sigma_{ext}$ [$\sqrt{mV}$/ms]', fontsize=15) plt.legend([line_mu_final[0], line_sig_final[0]], [line_mu_final[0].get_label(), line_sig_final[0].get_label()]) pidx +=1 if plot_rates: ax_rate = fig.add_subplot(nr_p, 1, pidx, sharex=ax_mu) for model in model_results['run_model']: color = params['color'][model] lw = params['lw'][model] key = 'results_{}'.format(model) time = model_results[key]['t'] rates = model_results[key]['r']
def something(rundir, file_no): my_path = os.getcwd() #print(my_path) working_dir = my_path + '/' + rundir #print(working_dir) efield_dir = working_dir + '/MS/FLD/e1/' laser_dir = working_dir + '/MS/FLD/e2/' eden_dir = working_dir + '/MS/DENSITY/electrons/charge/' iden_dir = working_dir + '/MS/DENSITY/ions/charge/' phase_space_dir = working_dir + '/MS/PHA/p1x1/ions/' p1x1_dir = working_dir + '/MS/PHA/p1x1/electrons/' efield_prefix = 'e1-' laser_prefix = 'e2-' phase_prefix = 'p1x1-ions-' p1x1_prefix = 'p1x1-electrons-' eden_prefix = 'charge-electrons-' iden_prefix = 'charge-ions-' fig = plt.figure(figsize=(12, 16)) filename1 = phase_space_dir + phase_prefix + repr(file_no).zfill( 6) + '.h5' filename2 = eden_dir + eden_prefix + repr(file_no).zfill(6) + '.h5' filename3 = efield_dir + efield_prefix + repr(file_no).zfill(6) + '.h5' filename4 = laser_dir + laser_prefix + repr(file_no).zfill(6) + '.h5' filename5 = p1x1_dir + p1x1_prefix + repr(file_no).zfill(6) + '.h5' filename6 = iden_dir + iden_prefix + repr(file_no).zfill(6) + '.h5' #print(filename1) #print(filename2) phase_space = np.abs(osh5io.read_h5(filename1)) # print(repr(phase_space)) eden = osh5io.read_h5(filename2) ex = osh5io.read_h5(filename3) ey = osh5io.read_h5(filename4) p1x1 = np.abs(osh5io.read_h5(filename5)) iden = osh5io.read_h5(filename6) phase_plot = plt.subplot(325) #print(repr(phase_space.axes[0].min)) #print(repr(phase_space.axes[1].min)) title = phase_space.data_attrs['LONG_NAME'] time = phase_space.run_attrs['TIME'][0] fig.suptitle('Time = ' + repr(time) + '$\omega_p^{-1}$', fontsize=24) ext_stuff = [ phase_space.axes[1].min, phase_space.axes[1].max, phase_space.axes[0].min, phase_space.axes[0].max ] data_max = max(np.abs(np.amax(phase_space)), 100) #print(repr(data_max)) phase_contour = plt.contourf( np.abs(phase_space + 0.000000001), levels=[ 0.00001 * data_max, 0.0001 * data_max, 0.001 * data_max, 0.01 * data_max, 0.05 * data_max, 0.1 * data_max, 0.2 * data_max, 0.5 * data_max ], extent=ext_stuff, cmap='Spectral', vmin=1e-5 * data_max, vmax=1.5 * data_max, norm=colors.LogNorm(vmin=0.00001 * data_max, vmax=1.5 * data_max)) phase_plot.set_title('Ion P1X1 Phase Space') phase_plot.set_xlabel('Position [$c / \omega_{p}$]') phase_plot.set_ylabel('Proper Velocity $\gamma v_1$ [ c ]') second_x = plt.twinx() second_x.plot(ex.axes[0], ex, 'g', linestyle='-.') #plt.colorbar() #osh5vis.oscontour(phase_space,levels=[10**-5,10**-3,10**-1,1,10,100],colors='black',linestyles='dashed',vmin=1e-5,vmax=1000) # plt.contour(np.abs(phase_space+0.000001),levels=[0.0001,0.001,0.01,0.05,0.1,0.2,0.5,1],extent=ext_stuff,colors='black',linestyles='dashed') plt.colorbar(phase_contour) den_plot = plt.subplot(323) osh5vis.osplot(eden, title='Electron Density') iden_plot = plt.subplot(324) osh5vis.osplot(iden, title='Ion Density') # for i in range(ex.shape[0]-2,-1,-1): # ex[i]=ex[i+1] + ex.axes[0].increment*ex[i] ex_plot = plt.subplot(322) osh5vis.osplot(ex, title='Wake E-field ', ylabel='$E_1 [m_e c^2/e]$') ey_plot = plt.subplot(321) osh5vis.osplot(ey, title='Laser Electric Field')
def tenpar_plot(): import os import numpy as np import matplotlib.pyplot as plt from matplotlib.backends.backend_pdf import PdfPages import pandas as pd from pyemu import Pst d = os.path.join("smoother","10par_xsec") pst = Pst(os.path.join(d,"10par_xsec.pst")) plt_dir = os.path.join(d,"plot") if not os.path.exists(plt_dir): os.mkdir(plt_dir) par_files = [os.path.join(d,f) for f in os.listdir(d) if "parensemble." in f and ".png" not in f] par_dfs = [pd.read_csv(par_file,index_col=0).apply(np.log10) for par_file in par_files] par_names = list(par_dfs[0].columns) mx = (pst.parameter_data.loc[:,"parubnd"] * 1.1).apply(np.log10) mn = (pst.parameter_data.loc[:,"parlbnd"] * 0.9).apply(np.log10) obj_df = pd.read_csv(os.path.join(d,"10par_xsec.pst.iobj.csv"),index_col=0) real_cols = [col for col in obj_df.columns if col.startswith("0")] obj_df.loc[:,real_cols] = obj_df.loc[:,real_cols].apply(np.log10) obj_df.loc[:,"mean"] = obj_df.loc[:,"mean"].apply(np.log10) obj_df.loc[:, "std"] = obj_df.loc[:, "std"].apply(np.log10) fig = plt.figure(figsize=(20, 10)) ax = plt.subplot(111) axt = plt.twinx() obj_df.loc[:, real_cols].plot(ax=ax, lw=0.5, color="0.5", alpha=0.5, legend=False) ax.plot(obj_df.index, obj_df.loc[:, "mean"], 'b', lw=2.5,marker='.',markersize=5) #ax.fill_between(obj_df.index, obj_df.loc[:, "mean"] - (1.96 * obj_df.loc[:, "std"]), # obj_df.loc[:, "mean"] + (1.96 * obj_df.loc[:, "std"]), # facecolor="b", edgecolor="none", alpha=0.25) axt.plot(obj_df.index,obj_df.loc[:,"lambda"],"k",dashes=(2,1),lw=2.5) ax.set_ylabel("log$_10$ phi") axt.set_ylabel("lambda") ax.set_title("total runs:{0}".format(obj_df.total_runs.max())) plt.savefig(os.path.join(plt_dir,"iobj.pdf")) plt.close() with PdfPages(os.path.join(plt_dir,"parensemble.pdf")) as pdf: for par_file,par_df in zip(par_files,par_dfs): print(par_file) fig = plt.figure(figsize=(20,10)) plt.figtext(0.5,0.975,par_file,ha="center") axes = [plt.subplot(2,6,i+1) for i in range(len(par_names))] for par_name,ax in zip(par_names,axes): mean = par_df.loc[:,par_name].mean() std = par_df.loc[:,par_name].std() par_df.loc[:,par_name].hist(ax=ax,edgecolor="none", alpha=0.5,grid=False) ax.set_yticklabels([]) ax.set_title("{0}, {1:6.2f}".\ format(par_name,10.0**mean)) ax.set_xlim(mn[par_name],mx[par_name]) ylim = ax.get_ylim() if "stage" in par_name: val = np.log10(1.5) else: val = np.log10(2.5) ticks = ["{0:2.1f}".format(x) for x in 10.0**ax.get_xticks()] ax.set_xticklabels(ticks,rotation=90) ax.plot([val,val],ylim,"k-",lw=2.0) ax.plot([mean,mean],ylim,"b-",lw=1.5) ax.plot([mean+(2.0*std),mean+(2.0*std)],ylim,"b--",lw=1.5) ax.plot([mean-(2.0*std),mean-(2.0*std)],ylim,"b--",lw=1.5) pdf.savefig() plt.close() obs_files = [os.path.join(d,f) for f in os.listdir(d) if "obsensemble." in f and ".png" not in f] obs_dfs = [pd.read_csv(obs_file) for obs_file in obs_files] #print(obs_files) #mx = max([obs_df.obs.max() for obs_df in obs_dfs]) #mn = min([obs_df.obs.min() for obs_df in obs_dfs]) #print(mn,mx) obs_names = ["h01_04","h01_06","h01_08","h02_08"] #print(obs_files) obs_dfs = [obs_df.loc[:,obs_names] for obs_df in obs_dfs] mx = {obs_name:max([obs_df.loc[:,obs_name].max() for obs_df in obs_dfs]) for obs_name in obs_names} mn = {obs_name:min([obs_df.loc[:,obs_name].min() for obs_df in obs_dfs]) for obs_name in obs_names} with PdfPages(os.path.join(plt_dir,"obsensemble.pdf")) as pdf: for obs_file,obs_df in zip(obs_files,obs_dfs): fig = plt.figure(figsize=(10,10)) plt.figtext(0.5,0.975,obs_file,ha="center") print(obs_file) axes = [plt.subplot(2,2,i+1) for i in range(len(obs_names))] for ax,obs_name in zip(axes,obs_names): mean = obs_df.loc[:,obs_name].mean() std = obs_df.loc[:,obs_name].std() obs_df.loc[:,obs_name].hist(ax=ax,edgecolor="none", alpha=0.5,grid=False) ax.set_yticklabels([]) #print(ax.get_xlim(),mn[obs_name],mx[obs_name]) ax.set_title("{0}, {1:6.2f}:{2:6.2f}".format(obs_name,mean,std)) #ax.set_xlim(mn[obs_name],mx[obs_name]) ax.set_xlim(0.0,20.0) ylim = ax.get_ylim() oval = pst.observation_data.loc[obs_name,"obsval"] ax.plot([oval,oval],ylim,"k-",lw=2) ax.plot([mean,mean],ylim,"b-",lw=1.5) ax.plot([mean+(2.0*std),mean+(2.0*std)],ylim,"b--",lw=1.5) ax.plot([mean-(2.0*std),mean-(2.0*std)],ylim,"b--",lw=1.5) pdf.savefig() plt.close()
def ts_fit_graph(ts, params): """Create graphic showing an histogram of the data and the distribution fitted to it. The graphic contains one panel per watershed. Parameters ---------- ts : xr.DataArray Stream flow time series with dimensions (time, nbasins). params : xr.DataArray Fitted distribution parameters returned by `xclim.land.fit` indicator. Returns ------- fig Figure showing a histogram and the parameterized pdf. """ from xclim.indices.stats import get_dist n = ts.nbasins.size dist = params.attrs["scipy_dist"] fig, axes = plt.subplots(n, figsize=(10, 6), squeeze=False) for i in range(n): ax = axes.flat[i] ax2 = plt.twinx(ax) p = params.isel(nbasins=i) t = ts.isel(nbasins=i).dropna(dim="time") # Plot histogram of time series as density then as a normal count. density, bins, patches = ax.hist( t, alpha=0.5, density=True, bins="auto", label="__nolabel__", ) ax2.hist( t, bins=bins, facecolor=(1, 1, 1, 0.01), edgecolor="gray", linewidth=1, ) # Plot pdf of distribution dc = get_dist(dist)(*params.isel(nbasins=i)) mn = dc.ppf(0.01) mx = dc.ppf(0.99) q = np.linspace(mn, mx, 200) pdf = dc.pdf(q) ps = ", ".join([f"{x:.1f}" for x in p.values]) ax.plot(q, pdf, "-", label="{}({})".format(params.attrs["scipy_dist"], ps)) # Labels ax.set_xlabel(f"{ts.long_name} (${units2pint(ts.units):~P}$)") ax.set_ylabel("Probability density") ax2.set_ylabel("Histogram count") ax.legend(frameon=False) plt.tight_layout() return fig
safety_factor = 0.001 # dt_arr = np.load('dt_arr.npy') # print(dt_arr) # let gas cool at constant density data = evolve_constant_density(fc, final_time=final_time, safety_factor=safety_factor) p1, = pyplot.loglog(data["time"].to("Myr"), data["temperature"], color="black", label="T") pyplot.xlabel("Time [Myr]") pyplot.ylabel("T [K]") data["mu"] = data["temperature"] / \ (data["energy"] * (my_chemistry.Gamma - 1.) * fc.chemistry_data.temperature_units) pyplot.twinx() p2, = pyplot.semilogx(data["time"].to("Myr"), data["mu"], color="red", label="$\\mu$") pyplot.ylabel("$\\mu$") pyplot.legend([p1, p2], ["T", "$\\mu$"], fancybox=True, loc="center left") pyplot.savefig("cooling_cell.png") # save data arrays as a yt dataset yt.save_as_dataset({}, "cooling_cell.h5", data)
if test_img_group_manual_single_target is not None: print() print(img_name, " => ", empties_cnt) print() if test_img_group_manual_single_target is None: num_changed_list = np.array(num_changed_list) np.save(os.path.join(out_path, "LeNet5__num_changed.npy"), num_changed_list) print(num_changed_list) # plot if test_img_group_manual_single_target is None: plt.close("all") fig, ax_violin = plt.subplots() ax_unsolved = plt.twinx(ax_violin) changed_num_reshaped = np.array(num_changed_list).reshape(5, -1) plot_values = [] plot_unsolved_ratio = [] for view_idx in range(5): _plot_val = changed_num_reshaped[view_idx] plot_val = _plot_val[np.where(_plot_val < 10)] plot_values.append(plot_val) plot_unsolved_ratio.append(100 - 100. * plot_val.size / _plot_val.size) violin = ax_violin.violinplot(plot_values, positions=np.arange(5), showmeans=True, showextrema=True, showmedians=True) ratio_line = ax_unsolved.plot(plot_unsolved_ratio, marker="o", color="orange", label="Unsolved Boards Ratio") # handle legends label_flag = [] label_str = []
def bin_woe_iv(s, target, desc='Fineclass'): ''' Pass the feature and target series in (both should have the same index) Return the dataframe of woe IV stats and plots params: desc: by default 'Fineclass', can set as Coarse class with customised description ''' eval_df = pd.DataFrame({'feat': s, 'target': target}) eval_df.sort_values(by='feat') eval_df['good'] = (eval_df['target'] == 0) eval_df['bad'] = (eval_df['target'] == 1) eval_df_summary = eval_df.groupby('feat')[['good', 'bad' ]].sum().rename(columns={ 'good': 'N_good', 'bad': 'N_bad' }).reset_index() #get the numeric order of num part so 10. is not ranked before 2. eval_df_summary['feat_num_index'] = pd.to_numeric( eval_df_summary['feat'].map(lambda x: x.split('.')[0]), errors='coerce') eval_df_summary.sort_values(by=['feat_num_index', 'feat'], inplace=True) eval_df_summary = eval_df_summary.reset_index(drop=True) eval_df_summary[ 'N_count'] = eval_df_summary['N_good'] + eval_df_summary['N_bad'] num_good_total = eval_df_summary['N_good'].sum() num_bad_total = eval_df_summary['N_bad'].sum() eval_df_summary['dist_good'] = eval_df_summary['N_good'] / num_good_total eval_df_summary['dist_bad'] = eval_df_summary['N_bad'] / num_bad_total eval_df_summary['bin_count_perc'] = eval_df_summary['N_count'] / ( num_good_total + num_bad_total) eval_df_summary['woe'] = np.log(eval_df_summary['dist_good'] / eval_df_summary['dist_bad']).replace( np.inf, np.nan) eval_df_summary['logodds'] = np.log(eval_df_summary['N_good'] / eval_df_summary['N_bad']).replace( np.inf, np.nan) eval_df_summary['p_bad'] = (eval_df_summary['N_bad'] / eval_df_summary['N_count']).replace( np.inf, np.nan) eval_df_summary['iv'] = ( eval_df_summary['dist_good'] - eval_df_summary['dist_bad']) * eval_df_summary['woe'] s_total = eval_df_summary.sum().drop( ['feat_num_index', 'woe', 'logodds', 'p_bad']) s_total.iloc[0] = 'Total' eval_df_summary = eval_df_summary.append(s_total, ignore_index=True) eval_df_summary['var'] = s.name eval_df_summary['desc'] = desc print(desc) print('IV is ' + str(eval_df_summary['iv'].sum())) # if eval_df_summary['N_count'].sum()==((target==0)|(target==1)).sum(): # print('total number of rows match') # else: # print('total number of rows DOES NOT match') eval_df_summary_forplot = eval_df_summary.loc[ eval_df_summary['feat'] != 'Total'] plt.plot(eval_df_summary_forplot['woe'], label='woe', marker='.') plt.title(s.name + ' woe') plt.xticks(ticks=eval_df_summary_forplot.index.values, labels=eval_df_summary_forplot['feat'].values) plt.xticks(rotation=60) plt.legend(loc='upper left') plt.twinx() plt.bar(eval_df_summary_forplot.index, eval_df_summary_forplot['bin_count_perc'], alpha=0.1, label='bin_vol%') plt.legend(loc='upper right') plt.show() return eval_df_summary
def loadRunSTGNeuroML_L123(filename): 'Loads and runs the pyloric rhythm generator from NeuroML files.' # for graded synapses, else NeuroML event-based are used from load_synapses import load_synapses moose.Neutral('/library') # set graded to False to use event based synapses # if False, neuroml event-based synapses get searched for and loaded # True to load graded synapses graded_syn = True #graded_syn = False if graded_syn: load_synapses() neuromlR = NeuroML() ## readNeuroMLFromFile below returns: # This returns # populationDict = { # 'populationname1':('cellName',{('instanceid1'):moosecell, ... }) # , ... # } # (cellName and instanceid are strings, mooosecell is a moose.Neuron object instance) # and # projectionDict = { # 'projName1':('source','target',[('syn_name1','pre_seg_path','post_seg_path') # ,...]) # , ... # } populationDict, projectionDict = \ neuromlR.readNeuroMLFromFile(filename) soma1_path = populationDict['AB_PD'][1][0].path + '/Soma_0' soma1Vm = setupTable('somaVm', moose.Compartment(soma1_path), 'Vm') soma2_path = populationDict['LP'][1][0].path + '/Soma_0' soma2Vm = setupTable('somaVm', moose.Compartment(soma2_path), 'Vm') soma3_path = populationDict['PY'][1][0].path + '/Soma_0' soma3Vm = setupTable('somaVm', moose.Compartment(soma3_path), 'Vm') # monitor channel current channel_path = soma1_path + '/KCa_STG' channel_Ik = setupTable('KCa_Ik', moose.element(channel_path), 'Ik') # monitor Ca capool_path = soma1_path + '/CaPool_STG' capool_Ca = setupTable('CaPool_Ca', moose.element(capool_path), 'Ca') # monitor synaptic current soma2 = moose.element(soma2_path) print "Children of", soma2_path, "are:" for child in soma2.children: print child.className, child.path if graded_syn: syn_path = soma2_path + '/DoubExpSyn_Ach__cells-0-_AB_PD_0-0-_Soma_0' syn = moose.element(syn_path) else: syn_path = soma2_path + '/DoubExpSyn_Ach' syn = moose.element(syn_path) syn_Ik = setupTable('DoubExpSyn_Ach_Ik', syn, 'Ik') print "Reinit MOOSE ... " resetSim(['/elec', cells_path], simdt, plotdt, simmethod='hsolve') print "Using graded synapses? = ", graded_syn print "Running model filename = ", filename, " ... " moose.start(runtime) tvec = np.arange(0.0, runtime + 2 * plotdt, plotdt) tvec = tvec[:soma1Vm.vector.size] fig = plt.figure(facecolor='w', figsize=(10, 6)) axA = plt.subplot2grid((3, 2), (0, 0), rowspan=3, colspan=1, frameon=False) img = plt.imread('STG.png') imgplot = axA.imshow(img) for tick in axA.get_xticklines(): tick.set_visible(False) for tick in axA.get_yticklines(): tick.set_visible(False) axA.set_xticklabels([]) axA.set_yticklabels([]) ax = plt.subplot2grid((3, 2), (0, 1), rowspan=1, colspan=1) ax.plot(tvec, soma1Vm.vector * 1000, label='AB_PD', color='g', linestyle='solid') ax.set_xticklabels([]) ax.set_ylabel('AB_PD (mV)') ax = plt.subplot2grid((3, 2), (1, 1), rowspan=1, colspan=1) ax.plot(tvec, soma2Vm.vector * 1000, label='LP', color='r', linestyle='solid') ax.set_xticklabels([]) ax.set_ylabel('LP (mV)') ax = plt.subplot2grid((3, 2), (2, 1), rowspan=1, colspan=1) ax.plot(tvec, soma3Vm.vector * 1000, label='PY', color='b', linestyle='solid') ax.set_ylabel('PY (mV)') ax.set_xlabel('time (s)') fig.tight_layout() fig = plt.figure(facecolor='w') plt.plot(tvec, soma2Vm.vector * 1000, label='LP', color='r', linestyle='solid') plt.plot(tvec, soma3Vm.vector * 1000, label='PY', color='b', linestyle='solid') plt.legend() plt.xlabel('time (s)') plt.ylabel('Soma Vm (mV)') plt.figure(facecolor='w') plt.plot(tvec, channel_Ik.vector, color='b', linestyle='solid') plt.title('KCa current; Ca conc') plt.xlabel('time (s)') plt.ylabel('Ik (Amp)') plt.twinx() plt.plot(tvec, capool_Ca.vector, color='r', linestyle='solid') plt.ylabel('Ca (mol/m^3)') plt.figure(facecolor='w') plt.plot(tvec, syn_Ik.vector, color='b', linestyle='solid') plt.title('Ach syn current in ' + soma2_path) plt.xlabel('time (s)') plt.ylabel('Isyn (S)') print "Showing plots ..." plt.show()
def fit(self, train, test=None, fname=None): self.lr_hist = [] self.e = 1 input_shape = self.arch['input_shape'] output_shape = self.arch['output_shape'] offset_max = train.shape[2] - (input_shape[1] + output_shape[1]) output_idx = self.arch['output_idx'] def get_xy(b): offset = np.random.randint(0, offset_max, len(b)) x, y = [], [] for i, _offset in enumerate(offset): x.append(b[i][:, _offset:_offset + input_shape[1]]) _offset += input_shape[1] _b = b[i][output_idx] y.append(_b[:, _offset:_offset + output_shape[1]]) return np.array(x), np.array(y) if not test is None: x_test, y_test = get_xy(test) if not self._scaling is None: x_test, y_test = self._scaling_xy(x_test, y_test) def get_time(_sec): _day, _hour, _min = 0, 0, 0 _1day = 3600 * 24 if _sec > _1day: _day = _sec // _1day _sec -= _day * _1day if _sec > 3600: _hour = _sec // 3600 _sec -= _hour * 3600 if _sec > 60: _min = _sec // 60 _sec -= _min * 60 return int(_day), int(_hour), int(_min), int(_sec) history, _time = [], [] print_str = '' while self.e <= self.epoch: if self.e in self.anneal: self.opt._lr /= 2 self.lr_hist.append(self.opt._lr) s = time() x_train, y_train = get_xy(train) if not self._scaling is None: x_train, y_train = self._scaling_xy(x_train, y_train) perm = np.random.permutation(len(x_train)) if 0: print(input_shape, output_shape) print(x_train.shape, y_train.shape) _train = self.forward(x_train, perm, y=y_train, opt=self.opt) if not test is None: perm = np.arange(len(x_test)) _test = self.forward(x_test, perm, y=y_test) _cp = time() - s _time.append(_cp) print_str = ' ' * len(print_str) print(print_str, end='\r') print_str = f'{self.e:05d}/{self.epoch:05d} {_train.mean():.6f}' if not test is None: print_str += f' {_test.mean():.6f}' print_str += f' @ {_cp:.2f}sec' _sec = np.array(_time).mean() * (self.epoch - self.e) _day, _hour, _min, _sec = get_time(_sec) if _day > 0: print_str += f' / {_day:d}d-' else: print_str += ' / ' print_str += f'{_hour:02d}:{_min:02d}:{_sec:02d}' print(print_str, end='\r', flush=True) if test is None: history.append([self.e, _train.mean(), _cp]) else: history.append([self.e, _train.mean(), _test.mean(), _cp]) self.e += 1 _sec = np.array(_time).sum() _day, _hour, _min, _sec = get_time(_sec) print(f'\nFinished at {_day:d}d-{_hour:02d}:{_min:02d}:{_sec:02d}') if fname: history = np.array(history) plt.plot(history[:, 0], history[:, 1], label='train', alpha=.6) if not x_test is None: plt.plot(history[:, 0], history[:, 2], label='test', alpha=.6) plt.legend() plt.xscale('log') plt.yscale('log') plt.xlabel('epoch') plt.ylabel('Error') plt.grid() plt.twinx() plt.plot(history[:, 0], self.lr_hist, 'k', lw=1) plt.ylabel('learning rate') plt.yscale('log') plt.tight_layout() plt.savefig(fname) plt.clf() plt.close()
def main(): import argparse parser = argparse.ArgumentParser(description='SER example: MLP') parser.add_argument('--gpu', '-g', type=int, default=-1, help='GPU ID (negative value indicates CPU)') parser.add_argument('--layer', type=int, default=1, help='number of layes for turn') parser.add_argument('--unit', type=int, default=500, help='number of units for turn') parser.add_argument('--batchsize', '-b', type=int, default=100, help='number of images in each mini-batch') parser.add_argument('--dropout', '-d', type=float, default=0.4, help='value of dropout rate') parser.add_argument('--weightdecay', default=0.001, type=float, help='value of weight decay rate') parser.add_argument('--epoch', '-e', type=int, default=100, help='number of sweeps over the dataset to train') parser.add_argument('--train', default='datasets/signate/smile/train.txt', type=str, help='training file (.txt)') parser.add_argument('--valid', default='datasets/signate/smile/valid.txt', type=str, help='validation file (.txt)') parser.add_argument('--out', '-o', default='result-mlp_cw', help='directory to output the result') parser.add_argument('--noplot', action='store_true', help='disable PlotReport extension') parser.add_argument('--optim', default='adam', choices=['adam', 'adadelta'], help='type of optimizer') parser.add_argument('--cw', default='none', choices=['none', 'sum', 'norm'], help='type of class weight') args = parser.parse_args() # args = parser.parse_args(args=[]) print(json.dumps(args.__dict__, indent=2)) sys.stdout.flush() seed = 123 os.environ['PYTHONHASHSEED'] = str(seed) random.seed(seed) np.random.seed(seed) if args.gpu >= 0: chainer.backends.cuda.get_device_from_id(args.gpu).use() cuda.check_cuda_available() cuda.cupy.random.seed(seed) model_dir = args.out if not os.path.exists(model_dir): os.mkdir(model_dir) # データの読み込み labels = {'neu': 0, 'ang': 1, 'sad': 2, 'hap': 3} # labels = {'MA_CH': 0, 'FE_AD': 1, 'MA_AD': 2, 'FE_EL': 3, 'FE_CH': 4, 'MA_EL': 5} X_train, y_train, labels = load_data(args.train, labels=labels) X_eval, y_eval, labels = load_data(args.valid, labels=labels) n_class = len(labels) print('# train X: {}, y: {}, dim: {}, counts: {}'.format(len(X_train), len(y_train), len(X_train[0]), [y_train.count(x) for x in sorted(labels.values())])) print('# eval X: {}, y: {}, dim: {}, counts: {}'.format(len(X_eval), len(y_eval), 1, [y_eval.count(x) for x in sorted(labels.values())])) print('# class: {}, labels: {}'.format(n_class, labels)) class_weight = None class_count = np.array([y_train.count(x) for x in sorted(labels.values())], 'f') if args.cw == 'sum': class_weight = np.sum(class_count) / class_count elif args.cw == 'norm': class_weight = np.sum(class_count) / class_count class_weight = class_weight / np.max(class_weight) print('# class_weight: {}'.format(class_weight)) sys.stdout.flush() if args.gpu >= 0: class_weight = cuda.to_gpu(class_weight) with open(os.path.join(args.out, 'labels.pkl'), 'wb') as f: pickle.dump(labels, f) model = SER(n_layers=args.layer, n_outputs=n_class, n_units=args.unit, dropout_rate=args.dropout, class_weight=class_weight) if args.gpu >= 0: model.to_gpu(args.gpu) # 学習率 lr = 0.001 # 学習率の減衰 lr_decay = 0.99 # 勾配上限 grad_clip = 3 # Setup optimizer (Optimizer の設定) if args.optim == 'adam': optimizer = chainer.optimizers.Adam(alpha=lr, beta1=0.9, beta2=0.999, weight_decay_rate=args.weightdecay, eps=1e-8) elif args.optim == 'adadelta': optimizer = chainer.optimizers.AdaDelta() else: raise ValueError("Only support adam or adadelta.") # optimizer.add_hook(chainer.optimizer.GradientClipping(grad_clip)) optimizer.setup(model) # プロット用に実行結果を保存する train_loss = [] train_accuracy1 = [] train_accuracy2 = [] test_loss = [] test_accuracy1 = [] test_accuracy2 = [] min_loss = float('inf') best_accuracy = .0 start_at = time.time() cur_at = start_at # Learning loop for epoch in range(1, args.epoch + 1): # training train_iter = batch_iter([(x, t) for x, t in zip(X_train, y_train)], args.batchsize, shuffle=True) sum_train_loss = 0. sum_train_accuracy1 = 0. sum_train_accuracy2 = 0. K = 0 for X, t in train_iter: x = to_device(args.gpu, np.asarray(X, 'f')) t = to_device(args.gpu, np.asarray(t, 'i')) # 勾配を初期化 model.cleargrads() # 順伝播させて誤差と精度を算出 loss, accuracy = model(x, t) sum_train_loss += float(loss.data) * len(t) sum_train_accuracy1 += float(accuracy.data) * len(t) sum_train_accuracy2 += .0 K += len(t) # 誤差逆伝播で勾配を計算 loss.backward() optimizer.update() # 訓練データの誤差と,正解精度を表示 mean_train_loss = sum_train_loss / K mean_train_accuracy1 = sum_train_accuracy1 / K mean_train_accuracy2 = sum_train_accuracy2 / K train_loss.append(mean_train_loss) train_accuracy1.append(mean_train_accuracy1) train_accuracy2.append(mean_train_accuracy2) now = time.time() train_throughput = now - cur_at cur_at = now # evaluation test_iter = batch_iter([(x, t) for x, t in zip(X_eval, y_eval)], args.batchsize, shuffle=False) sum_test_loss = 0. sum_test_accuracy1 = 0. sum_test_accuracy2 = 0. K = 0 with chainer.no_backprop_mode(), chainer.using_config('train', False): y_true = [] y_pred = [] for X, t in test_iter: x = to_device(args.gpu, np.asarray(X, 'f')) t = to_device(args.gpu, np.asarray(t, 'i')) # 順伝播させて誤差と精度を算出 loss, accuracy = model(x, t) sum_test_loss += float(loss.data) * len(t) sum_test_accuracy1 += float(accuracy.data) * len(t) sum_test_accuracy2 += .0 K += len(t) y = model.predict(x) y_pred += np.argmax(cuda.to_cpu(y.data), axis=1).tolist() y_true += t.tolist() cm = confusion_matrix(y_true, y_pred) cm2 = cm / np.sum(cm, axis=1) uar = np.mean(np.diag(cm2)) sum_test_accuracy2 += uar * K # テストデータでの誤差と正解精度を表示 mean_test_loss = sum_test_loss / K mean_test_accuracy1 = sum_test_accuracy1 / K mean_test_accuracy2 = sum_test_accuracy2 / K test_loss.append(mean_test_loss) test_accuracy1.append(mean_test_accuracy1) test_accuracy2.append(mean_test_accuracy2) now = time.time() test_throughput = now - cur_at cur_at = now logger.info('' '[{:>3d}] ' 'T/loss={:.6f} ' 'T/acc1={:.6f} ' 'T/acc2={:.6f} ' 'T/sec= {:.6f} ' 'D/loss={:.6f} ' 'D/acc1={:.6f} ' 'D/acc2={:.6f} ' 'D/sec= {:.6f} ' 'rate={:.6f}' ''.format( epoch, mean_train_loss, mean_train_accuracy1, mean_train_accuracy2, train_throughput, mean_test_loss, mean_test_accuracy1, mean_test_accuracy2, test_throughput, optimizer.rho if args.optim == 'adadelta' else optimizer.lr ) ) sys.stdout.flush() # model と optimizer を保存する if args.gpu >= 0: model.to_cpu() if mean_test_loss < min_loss: min_loss = mean_test_loss print('saving early-stopped model (loss) at epoch {}'.format(epoch)) chainer.serializers.save_npz(os.path.join(model_dir, 'early_stopped-loss.model'), model) if mean_test_accuracy2 > best_accuracy: best_accuracy = mean_test_accuracy2 print('saving early-stopped model (uar) at epoch {}'.format(epoch)) chainer.serializers.save_npz(os.path.join(model_dir, 'early_stopped-uar.model'), model) # print('saving final model at epoch {}'.format(epoch)) chainer.serializers.save_npz(os.path.join(model_dir, 'final.model'), model) chainer.serializers.save_npz(os.path.join(model_dir, 'final.state'), optimizer) if args.gpu >= 0: model.to_gpu() sys.stdout.flush() # if args.optim == 'adam': # optimizer.alpha *= lr_decay # 精度と誤差をグラフ描画 if not args.noplot: ylim1 = [min(train_loss + test_loss), max(train_loss + test_loss)] # ylim2 = [min(train_accuracy1 + test_accuracy1 + train_accuracy2 + test_accuracy2), max(train_accuracy1 + test_accuracy1 + train_accuracy2 + test_accuracy2)] ylim2 = [0., 1.] # グラフ左 plt.figure(figsize=(10, 10)) plt.subplot(1, 2, 1) plt.ylim(ylim1) plt.plot(range(1, len(train_loss) + 1), train_loss, color='C1', marker='x') # plt.grid() plt.ylabel('loss') plt.legend(['train loss'], loc="lower left") plt.twinx() plt.ylim(ylim2) plt.plot(range(1, len(train_accuracy1) + 1), train_accuracy1, color='C0', marker='x') # plt.plot(range(1, len(train_accuracy2) + 1), train_accuracy2, color='C2', marker='x') plt.yticks(np.arange(ylim2[0], ylim2[1], .1)) plt.grid(True) # plt.ylabel('accuracy') plt.legend(['train acc'], loc="upper right") plt.title('Loss and accuracy of train.') # グラフ右 plt.subplot(1, 2, 2) plt.ylim(ylim1) plt.plot(range(1, len(test_loss) + 1), test_loss, color='C1', marker='x') # plt.grid() # plt.ylabel('loss') plt.legend(['test loss'], loc="lower left") plt.twinx() plt.ylim(ylim2) plt.plot(range(1, len(test_accuracy1) + 1), test_accuracy1, color='C0', marker='x') plt.plot(range(1, len(test_accuracy2) + 1), test_accuracy2, color='C2', marker='x') plt.yticks(np.arange(ylim2[0], ylim2[1], .1)) plt.grid(True) plt.ylabel('accuracy') plt.legend(['test acc', 'test uar'], loc="upper right") plt.title('Loss and accuracy of test.') plt.savefig('{}.png'.format(args.out)) # plt.savefig('{}-train.png'.format(os.path.splitext(os.path.basename(__file__))[0])) # plt.show() plt.close() cur_at = now index2label = {v: k for k, v in labels.items()} sorted_labels = [k for k, _ in sorted(labels.items(), key=lambda x: x[1], reverse=False)] # test (early_stopped model by loss) chainer.serializers.load_npz(os.path.join(model_dir, 'early_stopped-loss.model'), model) if args.gpu >= 0: model.to_gpu(args.gpu) test_iter = batch_iter([(x, t) for x, t in zip(X_eval, y_eval)], args.batchsize, shuffle=False) with chainer.no_backprop_mode(), chainer.using_config('train', False): y_true = [] y_pred = [] for X, t in test_iter: x = to_device(args.gpu, np.asarray(X, 'f')) y = model.predict(x) y_pred += np.argmax(cuda.to_cpu(y.data), axis=1).tolist() y_true += t print("\n==== Confusion matrix 1 (early_stopped-loss) ====\n") cm = confusion_matrix([index2label[x] for x in y_true], [index2label[x] for x in y_pred], labels=sorted_labels) print("\t{}".format("\t".join(sorted_labels))) for label, counts in zip(sorted_labels, cm): print("{}\t{}".format(label, "\t".join(map(str, counts)))) print("\n==== Confusion matrix 2 (early_stopped-loss) ====\n") cm2 = cm / np.sum(cm, axis=1).reshape(4, 1) uar = np.mean(np.diag(cm2)) print("\t{}".format("\t".join(sorted_labels))) for label, counts in zip(sorted_labels, cm2): print("{}\t{}".format(label, "\t".join(map(lambda x: "%.2f" % x, counts)))) print("\nUAR = {:.6f}".format(float(uar))) sys.stdout.flush() # グラフ描画 if not args.noplot: plt.figure() plt.imshow(cm2, interpolation='nearest', cmap=plt.cm.Blues) for i in range(cm2.shape[0]): for j in range(cm2.shape[1]): plt.text(j, i, "{:.2f}".format(cm2[i, j]), horizontalalignment="center", color="white" if cm2[i, j] > cm2.max() / 2 else "black") plt.title('Confusion matrix') plt.colorbar() tick_marks = np.arange(len(sorted_labels)) plt.xticks(tick_marks, sorted_labels, rotation=45) plt.yticks(tick_marks, sorted_labels) plt.tight_layout() plt.ylabel('True label') plt.xlabel('Predicted label') plt.savefig('{}-cm-early_stopped-loss.png'.format(args.out)) # plt.savefig('{}-train_cm.png'.format(os.path.splitext(os.path.basename(__file__))[0])) # plt.show() plt.close() print("\n==== Classification report (early_stopped-loss) ====\n") print(classification_report( [sorted_labels[x] for x in y_true], [sorted_labels[x] for x in y_pred] )) sys.stdout.flush() # test (early_stopped model by uar) chainer.serializers.load_npz(os.path.join(model_dir, 'early_stopped-uar.model'), model) if args.gpu >= 0: model.to_gpu(args.gpu) test_iter = batch_iter([(x, t) for x, t in zip(X_eval, y_eval)], args.batchsize, shuffle=False) with chainer.no_backprop_mode(), chainer.using_config('train', False): y_true = [] y_pred = [] for X, t in test_iter: x = to_device(args.gpu, np.asarray(X, 'f')) y = model.predict(x) y_pred += np.argmax(cuda.to_cpu(y.data), axis=1).tolist() y_true += t print("\n==== Confusion matrix 1 (early_stopped-uar) ====\n") cm = confusion_matrix([index2label[x] for x in y_true], [index2label[x] for x in y_pred], labels=sorted_labels) print("\t{}".format("\t".join(sorted_labels))) for label, counts in zip(sorted_labels, cm): print("{}\t{}".format(label, "\t".join(map(str, counts)))) print("\n==== Confusion matrix 2 (early_stopped-uar) ====\n") cm2 = cm / np.sum(cm, axis=1).reshape(4, 1) uar = np.mean(np.diag(cm2)) print("\t{}".format("\t".join(sorted_labels))) for label, counts in zip(sorted_labels, cm2): print("{}\t{}".format(label, "\t".join(map(lambda x: "%.2f" % x, counts)))) print("\nUAR = {:.6f}".format(float(uar))) sys.stdout.flush() # グラフ描画 if not args.noplot: plt.figure() plt.imshow(cm2, interpolation='nearest', cmap=plt.cm.Blues) for i in range(cm2.shape[0]): for j in range(cm2.shape[1]): plt.text(j, i, "{:.2f}".format(cm2[i, j]), horizontalalignment="center", color="white" if cm2[i, j] > cm2.max() / 2 else "black") plt.title('Confusion matrix') plt.colorbar() tick_marks = np.arange(len(sorted_labels)) plt.xticks(tick_marks, sorted_labels, rotation=45) plt.yticks(tick_marks, sorted_labels) plt.tight_layout() plt.ylabel('True label') plt.xlabel('Predicted label') plt.savefig('{}-cm-early_stopped-uar.png'.format(args.out)) # plt.savefig('{}-train_cm.png'.format(os.path.splitext(os.path.basename(__file__))[0])) # plt.show() plt.close() print("\n==== Classification report (early_stopped-uar) ====\n") print(classification_report( [sorted_labels[x] for x in y_true], [sorted_labels[x] for x in y_pred] )) sys.stdout.flush() # test (final model) chainer.serializers.load_npz(os.path.join(model_dir, 'final.model'), model) if args.gpu >= 0: model.to_gpu(args.gpu) test_iter = batch_iter([(x, t) for x, t in zip(X_eval, y_eval)], args.batchsize, shuffle=False) with chainer.no_backprop_mode(), chainer.using_config('train', False): y_true = [] y_pred = [] for X, t in test_iter: x = to_device(args.gpu, np.asarray(X, 'f')) y = model.predict(x) y_pred += np.argmax(cuda.to_cpu(y.data), axis=1).tolist() y_true += t print("\n==== Confusion matrix 1 (final model) ====\n") cm = confusion_matrix([index2label[x] for x in y_true], [index2label[x] for x in y_pred], labels=sorted_labels) print("\t{}".format("\t".join(sorted_labels))) for label, counts in zip(sorted_labels, cm): print("{}\t{}".format(label, "\t".join(map(str, counts)))) print("\n==== Confusion matrix 2 (final model) ====\n") cm2 = cm / np.sum(cm, axis=1).reshape(4, 1) uar = np.mean(np.diag(cm2)) print("\t{}".format("\t".join(sorted_labels))) for label, counts in zip(sorted_labels, cm2): print("{}\t{}".format(label, "\t".join(map(lambda x: "%.2f" % x, counts)))) print("\nUAR = {:.6f}".format(float(uar))) sys.stdout.flush() # グラフ描画 if not args.noplot: plt.figure() plt.imshow(cm2, interpolation='nearest', cmap=plt.cm.Blues) for i in range(cm2.shape[0]): for j in range(cm2.shape[1]): plt.text(j, i, "{:.2f}".format(cm2[i, j]), horizontalalignment="center", color="white" if cm2[i, j] > cm2.max() / 2 else "black") plt.title('Confusion matrix') plt.colorbar() tick_marks = np.arange(len(sorted_labels)) plt.xticks(tick_marks, sorted_labels, rotation=45) plt.yticks(tick_marks, sorted_labels) plt.tight_layout() plt.ylabel('True label') plt.xlabel('Predicted label') plt.savefig('{}-cm-final.png'.format(args.out)) # plt.savefig('{}-cm-final.png'.format(os.path.splitext(os.path.basename(__file__))[0])) # plt.show() plt.close() print("\n==== Classification report (final model) ====\n") print(classification_report( [sorted_labels[x] for x in y_true], [sorted_labels[x] for x in y_pred] )) sys.stdout.flush()
np.ctypeslib.ndpointer(dtype=data_t, ndim=1, flags='C_CONTIGUOUS'), ] lib.stalta.restype = C.c_int def stalta(data, nsta, nlta): # initialize C struct / numpy structed array head = np.empty(1, dtype=head_t) head[:] = (len(data), nsta, nlta) # ensure correct type and countiguous of data data = np.require(data, dtype=data_t, requirements=['C_CONTIGUOUS']) # all memory should be allocated by python charfct = np.empty(len(data), dtype=data_t) # run and check the errorcode errcode = lib.stalta(head, data, charfct) if errcode != 0: raise Exception('stalta exited with error code %d' % errcode) return charfct if __name__ == '__main__': from obspy.core import read import matplotlib.pyplot as plt tr = read("/path/to/loc_RJOB20050831023349.z")[0] charfct = stalta(tr.data, 400, 2000) plt.plot(tr.data) plt.twinx().plot(charfct, 'r') plt.show()
# turn on grid if opts.is_grid == True: plt.grid(True) axbot = plt.twiny() axbot.xaxis.tick_bottom() axbot.xaxis.set_label_position("bottom") if opts.is_period_doubled and bin_start == 0 and bin_end == opts.nbins - 1: axbot.set_xlim(xmin=opts.phase_start, xmax=2.*opts.phase_end) else: axbot.set_xlim(xmin=opts.phase_start, xmax=opts.phase_end) for label in axbot.get_xticklabels(): label.set_fontsize(opts.fs) plt.xlabel("Pulse phase", fontsize=opts.fs) plt.gca().minorticks_on() ayleft = plt.twinx() ayleft.yaxis.tick_left() ayleft.yaxis.set_label_position("left") if (dump_pulses > 0 or dump_time > 0) and not opts.is_events: ayleft.set_ylim(ymin=0.0, ymax=ncount*dump_time) else: ayleft.set_ylim(ymin=0.0, ymax=opts.window_time) for label in ayleft.get_yticklabels(): label.set_fontsize(opts.fs) plt.ylabel("Observing time (s)", fontsize=opts.fs) plt.gca().minorticks_on() # Determining the main (top/right) axes if opts.is_period_doubled and bin_start == 0 and bin_end == opts.nbins - 1: ax.set_xlim(xmin=bin_start, xmax=opts.nbins + bin_end-0.1) else: ax.set_xlim(xmin=bin_start, xmax=bin_end-0.1)
# Display the new image with 'gray' color map plt.subplot(2, 1, 1) plt.title('Equalized image') plt.axis('off') plt.imshow(new_image, cmap='gray') # generate a hist of new pixels plt.subplot(2, 1, 2) pdf = plt.hist(new_pixels, bins=64, range=(0, 256), normed=False, color='red', alpha=0.4) plt.grid('off') plt.twinx() plt.xlim((0, 256)) plt.grid('off') plt.title('PDF & CDF (equalized image)') # generate a cumulative hist of new pixels plt.hist(new_pixels, bins=64, range=(0, 256), normed=True, color='blue', alpha=.4, cumulative=True) plt.show()
''' Tow y axis in plot with different scale ''' import numpy as np import matplotlib matplotlib.use('TkAgg') import matplotlib.pyplot as plt x = np.arange(2, 20, 1) y1 = x * x y2 = np.log(x) plt.plot(x, y1) plt.twinx() # add more y axis plt.plot(x, y2, 'r') plt.show()
results Rec = [] Precision = [] Recall = [] for i in range(0, 9): Rec.append(results[i]['K']) Precision.append(results[i]['Precision']) Recall.append(results[i]['Recall']) from matplotlib import pyplot as plt plt.plot(Rec, Precision) plt.xlabel('# of Recommendations') plt.ylabel('Precision') plt2 = plt.twinx() plt2.plot(Rec, Recall, 'r') plt.ylabel('Recall') for tl in plt2.get_yticklabels(): tl.set_color('r') #data = Dataset.load_builtin('ml-100k') trainset = data.build_full_trainset() #Build on entire data set algo = SVD(n_factors=factors, n_epochs=epochs, lr_all=lr_value, reg_all=reg_value) algo.fit(trainset) # Predict ratings for all pairs (u, i) that are NOT in the training set. testset = trainset.build_anti_testset()
def summary_plot(self): ''' Plot a summary plot for the chemical evolution model. The star formation rate, inflow rate, SNIa and SNII rates at the solar radius are plotted along with observational constraints from Guesten & Mezger et al. (1982) (for the SFR) Portinari et al. (1998) (for the inflow) and Li et al. (2011) (for the SN rates) ''' plt.figure(figsize=[3., 4.]) plt.subplot(2, 1, 1) plt.plot(self.t, self.SFR, color='k', label='SFR') l, = plt.plot(self.t, self.Inflow, color='k', ls='dashed', label='Inflow') l.set_dashes((2, 1)) plt.legend(loc='upper left', bbox_to_anchor=(0.1, 1.0)) plt.xlabel(r'$t/\,\mathrm{Gyr}$') plt.ylabel( r'Rate /$\,\mathrm{M}_\odot\,\mathrm{pc}^{-2}\,\mathrm{Gyr}^{-1}$') plt.ylim(0., np.max(self.SFR) * 1.4) sfr = [6., 4.] # Guesten & Mezger et al. (1982) inf = [0.9, 0.6] # Portinari et al. (1998) plt.errorbar([11.8], [sfr[0]], yerr=[sfr[1]], color=sns.color_palette()[2], fmt='*', markersize=4) plt.errorbar([11.8], [inf[0]], yerr=[inf[1]], color=sns.color_palette()[2], fmt='*', markersize=4) ax = plt.twinx() plt.plot(self.t, self.SNIa, color='k', ls='dotted', label='SNIa') l, = plt.plot(self.t, self.SNII, color='k', ls='dashed', label='SNII') l.set_dashes((4, 1)) plt.ylabel(r'Rate /$\,\mathrm{pc}^{-2}\,\mathrm{Gyr}^{-1}$') plt.legend(loc='upper right', bbox_to_anchor=(0.9, 1.0)) plt.ylim(0., plt.ylim()[1] * 1.4) typeII = [1.555, 0.285] # Li et al. (2011) typeIa = [0.54, 0.11] # Li et al. (2011) ## Assuming 15kpc disc conv = 10. / np.pi / 15.**2 plt.errorbar([12.2], [typeIa[0] * conv], yerr=[typeIa[1] * conv], color=sns.color_palette()[1], fmt='o', markersize=2) plt.errorbar([12.2], [typeII[0] * conv], yerr=[typeII[1] * conv], color=sns.color_palette()[1], fmt='o', markersize=2) plt.xlim(0., self.t[-1] * 1.05) plt.subplot(2, 1, 2) plt.plot(self.R, self.Mstar[-1], color='k', label='Stars') l, = plt.plot(self.R, self.Mgas[-1], color='k', ls='', label='Gas') l.set_dashes((2, 1)) plt.legend(loc='upper right', bbox_to_anchor=(0.9, 1.0)) plt.errorbar([SolarRadius, SolarRadius], [43., 13.], yerr=[5., 3.], fmt='o', markersize=2) plt.xlim(2., 16.) plt.semilogy() plt.xlabel(r'$R/\,\mathrm{kpc}$') plt.ylabel(r'Surface Density$/\,\mathrm{M}_\odot\,\mathrm{pc}^{-2}$') plt.tight_layout()
# 设置中文格式为黑体 plt.rcParams['font.sans-serif'] = ['SimHei'] plt.rcParams['axes.unicode_minus'] = False #解决负号显示为方块的问题 # 读取数据 data = pd.read_excel('data.xlsx') # 把日期由string字符串格式转为timestamp时间戳格式,方便坐标轴显示 """ 1.先创建空集用于放置转换后的日期 2. """ d = [] for i in range(len(data)): d.append(datetime.datetime.strptime(data['date'][i], '%Y-%m-%d')) data['date'] = d # 将原来的date那一列数据换成新生成的时间戳格式日期 # 数据可视化并设置双坐标轴 plt.plot(data['date'], data['score'], linestyle='--', label='评分') plt.xticks(rotation=45) # 设置x轴刻度显示角度 plt.legend(loc='upper left') # 分数的图例设置在左上角 plt.twinx() # 设置双坐标轴 plt.plot(data['date'], data['price'], color='red', label='股价') plt.xticks(rotation=45) plt.legend(loc='upper right') plt.gcf().autofmt_xdate() #自动调整角度 plt.show()
def gen_svg_tiles(path_dest, catalog, last_hours=(72, 48, 24), color=COLOR_TILES): """ Generate tiles (svg evolution plots of sensor variables) for enerpiweb :param str path_dest: IMG_TILES_BASEPATH = os.path.join(BASE_PATH, '..', 'enerpiweb', 'static', 'img', 'generated') :param HDFTimeSeriesCatalog catalog: ENERPI data catalog :param tuple last_hours: with hour intervals to plot. Default 72, 48, 24 h :param tuple color: color for lines in tiles (default: white, (1, 1, 1)) :return: ok :rtype: bool """ def _cut_axes_and_save_svgs(figure, axes, x_lim, delta_total, data_name, tile_gradient_end, tile_gradient_st, preserve_ratio=False): for i, lh in enumerate(last_hours): file = os.path.join( path_dest, 'tile_{}_{}_last_{}h.svg'.format('enerpi_data', data_name, lh)) axes.set_xlim( (x_lim[0] + delta_total * (1 - lh / total_hours), x_lim[1])) figure.set_figwidth(_tile_figsize(lh / total_hours)[0]) write_fig_to_svg(figure, name_img=file, preserve_ratio=preserve_ratio) # if (i + 1 == len(last_hours)): if EXPORT_PNG_TILES and (i + 1 == len(last_hours)): path_png = file[:-3] + 'png' base_path, name_png = os.path.split(path_png) figure.set_dpi(216) canvas = FigureCanvas(figure) canvas.draw() # Fusion data + bg: data_img = Image.frombytes('RGBA', (900, 600), canvas.buffer_rgba()) png_img = _get_png_tile_background( os.path.join(base_path, 'fondo_' + name_png), (data_img.width, data_img.height), tile_gradient_end, tile_gradient_st) png_img.paste(data_img, (0, 0), data_img) png_img.save(path_png) fig = ax = None total_hours = last_hours[0] last_data, last_data_c = catalog.get(last_hours=last_hours[0], with_summary=True) if (last_data is not None) and (len(last_data) > 2): ahora = dt.datetime.now().replace(second=0, microsecond=0) xlim = mpd.date2num(ahora - dt.timedelta( hours=last_hours[0])), mpd.date2num(ahora) delta = xlim[1] - xlim[0] for c in SENSORS.columns_sensors_rms: fig, ax = _plot_sensor_tile(catalog.resample_data(last_data[c], rs_data='5min'), barplot=False, ax=ax, fig=fig, color=color) _cut_axes_and_save_svgs(fig, ax, xlim, delta, c, SENSORS[c].tile_gradient_end, SENSORS[c].tile_gradient_st) plt.cla() fig.set_figwidth(_tile_figsize()[0]) for c in SENSORS.columns_sensors_mean: fig, ax = _plot_sensor_tile(catalog.resample_data(last_data[c], rs_data='30s', use_median=True), barplot=False, ax=ax, fig=fig, color=color) _cut_axes_and_save_svgs(fig, ax, xlim, delta, c, SENSORS[c].tile_gradient_end, SENSORS[c].tile_gradient_st) plt.cla() fig.set_figwidth(_tile_figsize()[0]) # (DEBUG Control decay) svg de 'ref' # c = SENSORS.ref_rms # fig, ax = _plot_sensor_tile(catalog.resample_data(last_data[c], rs_data='30s'), # barplot=False, ax=ax, fig=fig, color=(0.5922, 0.149, 0.1451)) # _cut_axes_and_save_svgs(fig, ax, xlim, delta, c, preserve_ratio=True) # plt.cla() # fig.set_figwidth(_tile_figsize()[0]) # Consumption tile (€ & kWh) if len(last_data_c) > 1: fig, ax = _plot_sensor_tile(last_data_c.kWh, barplot=True, ax=ax, fig=fig, color=color) # Append cost data: fact = FacturaElec(consumo=last_data_c.kWh) last_data_coste = fact.reparto_coste().tz_localize(None) last_data_coste.index = last_data_coste.index + dt.timedelta( minutes=30) coste_max = last_data_coste.max() step_c = 0.05 c_max = max(3 * step_c, np.ceil(coste_max * 100) / 100.) yticks = list(np.arange(start=0, stop=c_max, step=step_c))[1:-2] ax_2 = plt.twinx(ax) ax_2.plot(last_data_coste, color=color, lw=2, ls='-.') ax_2.tick_params(axis='y', direction='in', pad=-40, length=3, width=.5, labelsize=FONTSIZE_TILE, labelright=True, colors='k') ax_2.set_ylim((0, c_max)) ax_2.set_yticks(yticks) ax_2.set_yticklabels(['{:.02f} €'.format(t) for t in yticks]) ax.annotate('{:.1f}kWh'.format(last_data_c.kWh.iloc[-25:-1].sum()), (.1, .7), xycoords='axes fraction', verticalalignment='top', alpha=.8, bbox={ 'edgecolor': color, 'pad': 2, 'linewidth': 1, 'facecolor': color, 'alpha': 0.1 }, horizontalalignment='left', size=3 * FONTSIZE, color='k') ax.annotate('{:.2f}€'.format(last_data_coste.iloc[-25:-1].sum()), (.9, .7), xycoords='axes fraction', verticalalignment='top', alpha=.8, bbox={ 'edgecolor': color, 'pad': 2, 'linewidth': 1, 'facecolor': color, 'alpha': 0.1 }, horizontalalignment='right', size=3 * FONTSIZE, color='k') _cut_axes_and_save_svgs(fig, ax, xlim, delta, last_data_c.kWh.name, (191, 160, 245, 0.27), (140, 39, 211, 0.83)) if fig is not None: plt.close(fig) return True else: return False
tick.set_fontsize(12) for tick in plt.gca().get_yticklabels(): tick.set_fontname("Calibri") tick.set_fontsize(12) #Axis labels and formats # axis 1 color = 'tab:red' plt.xlabel("Date", fontsize=12) fig.autofmt_xdate() plt.ylabel(str(ticker1), color='black', fontsize=12) plt.plot(x_values_selected, y_values_selected, color=color) plt.tick_params(axis='y', labelcolor=color) ax2 = plt.twinx() # instantiate a second axes that shares the same x-axis #axis 2 color = 'tab:blue' ax2.set_ylabel(str(ticker2), color='black', fontsize=12) # we already handled the x-label with ax1 ax2.plot(x_values_selected, ticker_2.get_shareprice_data_y(), color=color) ax2.tick_params(axis='y', labelcolor=color) #remove borders plt.gca().spines['top'].set_visible(False) #Chart title plt.title(str(ticker1 + " & " + ticker2 + " share price chart"), fontsize=14) #Show chart
monitor.join() with open('feed_forward_data', 'w') as outfile: json.dump(dynamics, outfile) else: with open('feed_forward_data', 'r') as outfile: dynamics = json.load(outfile) plt.figure() fig, ax1 = plt.subplots() ax1.set_ylabel('CPU Load (%)', color='b') ax1.plot(dynamics['time'], dynamics['cpu'], 'b-') ax1.set_xlabel('Time [ms]') ax1.grid(True) ax1.set_ylim([0, 100]) for tl in ax1.get_yticklabels(): tl.set_color('b') ax2 = plt.twinx() ax2.set_ylabel('Input Load', color='r') cpuInput = [ 100 * inverse_cpu_model(x) for x in dynamics['sleepTimeTarget'] ] ax2.plot(dynamics['time'], cpuInput, 'r-') ax2.grid(True) ax2.set_ylim([0, 100]) for tl in ax2.get_yticklabels(): tl.set_color('r') plt.savefig('FeedForward.png', dpi=100) plt.close()
def gains_chart(loss, score, num_bins=10, title='Gains Chart', return_table=True, include_scores=True): """Show gains chart of binned scores along with KS and Gini.""" n = len(loss) df = pd.DataFrame({'loss': loss, 'score': score}) df = df.sort_values(by='score') # Initialize arrays that store aggregated values bin_scores = np.zeros(num_bins) bin_losses = np.zeros(num_bins) bin_sizes = np.zeros(num_bins) virtual_bins = num_bins min_score = np.min(score) max_score = np.max(score) raw_step_size = (max_score - min_score) / num_bins break_start = 0 break_end = num_bins breaks = np.linspace(min_score, max_score, virtual_bins + 1) for i in np.arange(break_start, break_end): bin_scores[i] = np.mean(df['score'][(df['score'] > breaks[i]) & (df['score'] <= breaks[i + 1])]) bin_losses[i] = np.mean(df['loss'][(df['score'] > breaks[i]) & (df['score'] <= breaks[i + 1])]) bin_sizes[i] = np.sum((df['score'] > breaks[i]) & (df['score'] <= breaks[i + 1])) # Convert gains chart table to DataFrame gains_chart_df = pd.DataFrame( { 'bin': np.arange(1, num_bins + 1), 'count': bin_sizes, 'avg_score': bin_scores, 'avg_loss': bin_losses }, index=np.arange(1, num_bins + 1)) gains_chart_df = gains_chart_df[['bin', 'count', 'avg_score', 'avg_loss']] # gains_chart_df['rl_avg_loss'] = gains_chart_df['avg_loss'] / np.mean(df['loss']) # gains_chart_df['rl_avg_score'] = gains_chart_df['avg_score'] / np.mean(df['score']) gini = ks_gini(loss, score) gini = "{:.3f}".format(gini['gini']) if include_scores: chart_min = min(np.min(gains_chart_df['avg_score']), np.min(gains_chart_df['avg_loss'])) - .1 chart_max = max(np.max(gains_chart_df['avg_score']), np.max(gains_chart_df['avg_loss'])) + .1 else: chart_min = np.min(gains_chart_df['avg_loss']) - .1 chart_max = np.max(gains_chart_df['avg_loss']) + .1 # Create the plot plt.ylim(min(chart_min, 0.0), max(1.0, chart_max)) plt.title(title + ', Gini: ' + gini) plt.grid() plt.xticks(np.arange(1, 11)) plt.plot(gains_chart_df['bin'], gains_chart_df['avg_loss'], zorder=15) plt.scatter(gains_chart_df['bin'], gains_chart_df['avg_loss'], s=15, label='_nolegend_', zorder=14) if include_scores: plt.plot(gains_chart_df['bin'], gains_chart_df['avg_score'], zorder=8) plt.scatter(gains_chart_df['bin'], gains_chart_df['avg_score'], s=15, label='_nolegend', zorder=7) plt.legend(bbox_to_anchor=(1.15, 1), loc=2, borderaxespad=0.) plt.ylabel('Avg Actual') plt.xlabel('Bin') axes2 = plt.twinx() axes2.set_ylabel('Count') axes2.bar(gains_chart_df['bin'], gains_chart_df['count'], zorder=2, color='grey') axes2.set_ylim(0, 3 * np.max(gains_chart_df['count'])) plt.show() plt.close() if return_table: return gains_chart_df return
def plot_back_test(self, ma_days): for ii in range(len(self.user_stock_code_list)): plt.figure(ii) ax = plt.gca() std = [] negetive_std = [] for jj in range(len(self.diviation_from_ma_list[ii])): temp_std = np.std( self.diviation_from_ma_list[ii][max(jj - ma_days + 1, 0):jj + 1]) std.append(temp_std) negetive_std.append(-1.0 * temp_std) plt.plot(self.user_stock_uniform_price_list[ii], color="k", linewidth=2.5, label="Price") #plt.plot(self.back_test_info[5][ii],color = "b",linewidth =2.5,label = "Return") plt.scatter(self.back_test_info[1][ii], self.back_test_info[2][ii], c="r", s=150, marker="s", label="Long") plt.scatter(self.back_test_info[3][ii], self.back_test_info[4][ii], c="g", s=150, marker="s", label="Short/Sell") plt.xlabel("Time /day") plt.ylabel("Return") plt.legend(loc="upper left") ax_2 = plt.twinx() ax_2.plot(self.diviation_from_ma_list[ii], color="y", linewidth=2.5, label="Diviation From MA") #ax_2.plot(self.diviation_from_ma_std_list[ii],color = "r",linewidth = 2.5,label= "Positive Std") #ax_2.plot(negetive_std,color = "g",linewidth = 2.5,label = "Negative Std") #for jj in range(len(self.ma_days_list)): ax_2.plot(self.diviation_ma_list[ii], color="c", linewidth=2.5, label=str(self.ma_dict[self.ma_days]) + " MA of Diviation") ax_2.legend(loc="upper right") ax_2.set_ylabel("Diviation From MA") #plt.ylim(0) plt.xlim(0) xticks = ax.get_xticks() offset = xticks[1] - xticks[0] date_time = [] for jj in range(len(xticks)): if jj * int(offset) >= len(self.user_stock_datetime_list[ii]): break date_time.append( self.user_stock_datetime_list[ii][jj * int(offset)]) ax.set_xticklabels(date_time, rotation=30) if self.short_flag == 1: plt.title(self.user_stock_name_list[ii] + "long/short return " + str(ma_days) + " MA") else: plt.title(self.user_stock_name_list[ii] + "long/hold return " + str(ma_days) + " MA") plt.grid(True) fig = plt.gcf() fig.set_size_inches(24, 15) fig.savefig("../input/DeviationFromMA/png_" + str(ma_days) + "/" + self.user_stock_code_list[ii] + "_return.png", dpi=100) plt.close(fig)
# Lines of constant Jeans Length plt.plot(rho, temp_jeans_length(rho, 1e1), color='green', linestyle='-') plt.plot(rho, temp_jeans_length(rho, 1e2), color='green', linestyle='-') plt.plot(rho, temp_jeans_length(rho, 1e3), color='green', linestyle='-') plt.plot(rho, temp_jeans_length(rho, 1e4), color='green', linestyle='-') anns = { r"$\lambda_J = 10 pc$": (7e1, 1e2), r"$\lambda_J = 100 pc$": (7e-1, 1e2), r"$\lambda_J = 10^3 pc$": (7e-3, 1e2), r"$\lambda_J = 10^4 pc$": (7e-5, 1e2) } annotate_lines(anns, 1, 'g') # Show sound speed as second y axis psound = plt.twinx() psound.set_ylabel('$c_s (km/s)$') temp_dyn_range = temp_range[1] - temp_range[0] temp_cs_vals = (np.log10( temp_sound_speed(np.array([3e0, 1e1, 3e1, 1e2, 3e2, 1e3, 3e3]))) - temp_range[0]) / temp_dyn_range psound.set_yticks(temp_cs_vals) psound.set_yticklabels(['3', '10', '30', '100', '300', '1,000', '3,000']) # Show free-fall time as second x axis pfall = plt.twiny() pfall.set_xlabel('$t_{ff} (Myr)$') rho_dyn_range = rho_range[1] - rho_range[0] rho_ff_vals = ( np.log10(rho_freefall(np.array([1e0, 1e1, 1e2, 1e3, 1e4, 1e5]))) - rho_range[0]) / rho_dyn_range
"Running Sim II" ] plt.ylim(0, 16) plt.xlim(0, len(reference)) plt.xticks(np.arange(len(reference)), reference) plt.xticks(rotation=-30, ha="left") plt.grid(True) plt.ylabel("Total RAM Memory [GiB]") plt.legend(lines, lines_legend) first_legend = plt.legend(lines, lines_legend) second_legend = plt.legend(patches, patches_legend, loc="center left") plt.gca().add_artist(first_legend) second_ax = plt.twinx() second_ax.set_ylabel("Total RAM Memory [%]") second_ax.set_ylim(0, 100) second_ax.set_zorder(0) mng = plt.get_current_fig_manager() mng.window.showMaximized() plt.tight_layout() plt.savefig(plot_file("AllTotalRAM.png"), bbox_inches='tight') #%% COMPARE SIMULATIONS I AND II crossed_reference = [ "Inicial", "mp.Simulation", "Flujo", "sim.init_sim()", "load_midflux()", "Flujo negado", "Principio", "Mitad", "Final"
def find_saddle(data,first_guess=240,nbins=50,xlims=[100,320],method='fmin',\ addtests=True,showplot=False,figd=False): '''Function to find the saddle between to peaks in a bimodal distribution. Usage: Best to plot a histogram of data first in order to make a good first guess The implemented deldxmin method has OLR typical proximity thresholds relative to first_guess value. ''' import scipy.interpolate as spi data = np.nan_to_num(data) #if showplot: # f,[ax1,ax2] = plt.subplots(2,1) # plt.axes(ax1) plt.figure(num='hist') hy, hx, hbars = plt.hist(data.ravel(), bins=nbins, normed=True, color='0.5', ec='k') plt.xlim(xlims) plt.ylabel('Raw Data') plt.yticks(np.arange(0.002, 0.016, 0.004)) Interpolator = spi.interp1d(hx[1:], hy, kind='cubic') if method == 'deldxmin': hires_x = np.linspace(xlims[0], xlims[1], 2000) y = Interpolator(hires_x) dx = y[1:] - y[:-1] ddx = dx[1:] - dx[:-1] if showplot: plt.axes(ax2) plt.plot(hires_x[:-1], dx, 'b') plt.plot(hires_x[:-1], np.abs(dx), 'g') plt.plot([hires_x[0], hires_x[-1]], [0, 0], 'b--') plt.twinx() plt.plot(hires_x[1:-1], ddx, 'r') plt.plot([hires_x[0], hires_x[-1]], [0, 0], 'r--') plt.axes(ax1) iddx_mask = ddx <= 0 data1, data2 = first_guess - 30, first_guess + 30 proximity_mask = (hires_x[1:-1] < data1) | (hires_x[1:-1] > data2) msk = iddx_mask | proximity_mask idx_masked = np.ma.MaskedArray(np.abs(dx[1:]), mask=msk) idx_zero = idx_masked.argmin() olr_saddle = hires_x[idx_zero] elif method == 'fmin': import scipy.optimize as spo [olr_saddle] = spo.fmin(Interpolator, first_guess, full_output=0, disp=0) olr_saddle = round(olr_saddle) if addtests: lower = olr_saddle - 5 upper = olr_saddle + 5 if showplot: plt.plot(olr_saddle, 0, 'k^', markersize=30) if addtests: plt.plot((lower, lower), (0, 0.014), 'k', lw=2) plt.plot((upper, upper), (0, 0.014), 'k', lw=2) figname = figd + 'olrhist_autothresh_' + str(olr_saddle) + '.png' plt.savefig(figname, dpi=150) plt.close() else: plt.close() return olr_saddle
plt.subplot(2, 3, 4) plt.plot(np.fft.rfftfreq(len(beam_x), d=1.), np.abs(np.fft.rfft(beam_x))) plt.ylabel('Amplitude') plt.xlabel('Qx') plt.subplot(2, 3, 5) plt.plot(np.fft.rfftfreq(len(beam_y), d=1.), np.abs(np.fft.rfft(beam_y))) plt.ylabel('Amplitude') plt.xlabel('Qy') plt.subplot(2, 3, 6) plt.plot(np.fft.rfftfreq(len(beam_z), d=1.), np.abs(np.fft.rfft(beam_z))) plt.xlim(0, 0.1) plt.ylabel('Amplitude') plt.xlabel('Qz') fig, axes = plt.subplots(3, figsize=(16, 8), tight_layout=True) twax = [plt.twinx(ax) for ax in axes] axes[0].plot(sx, label=r'$\sigma_x$') twax[0].plot(epsx, '-g', label=r'$\varepsilon_x$') axes[0].set_xlabel('Turns') axes[0].set_ylabel(r'$\sigma_x$') twax[0].set_ylabel(r'$\varepsilon_x$') axes[1].plot(sy, label=r'$\sigma_y$') twax[1].plot(epsy, '-g', label=r'$\varepsilon_y$') axes[1].set_xlabel('Turns') axes[1].set_ylabel(r'$\sigma_y$') twax[1].set_ylabel(r'$\varepsilon_y$') axes[2].plot(sz, label=r'$\sigma_z$') twax[2].plot(epsz, '-g', label=r'$\varepsilon_z$') axes[2].set_xlabel('Turns') axes[2].set_ylabel(r'$\sigma_z$') twax[2].set_ylabel(r'$\varepsilon_z$')
## Berm dates plt.axvline(datetime.datetime(2019, 9, 5), color='k', alpha=.8, ls=':') plt.axvline(x=datetime.datetime(2019, 12, 4), ymin=0, ymax=.83, color='k', alpha=.8, ls=':') plt.axvline(x=datetime.datetime(2019, 12, 4), ymin=0.96, ymax=1, color='k', alpha=.8, ls=':') ax2 = plt.twinx(plt.gca()) plt.plot(flow.index, flow.logflow, lw=1.75, color='#00264d', label='Discharge', zorder=1) ## Scott plt.ylabel('Discharge (log$_{10}$ft$^3$/s)', rotation=270, ha='center', va='baseline', rotation_mode='anchor') plt.ylim(1, 3) plt.xlim(dr[0], dr[-1]) offset = 7
def make_plot(Path, Parameters): #create blank figure plt.figure(1, figsize=(12, 6)) ax1 = plt.subplot(111) ax2 = plt.twinx() OffsetX = [0, 500, 800, 0, 600, 200, 350, 900, 0] OffsetZ = [50, 70, 90, 0, 30, 40, 80, 30, 120] for i in range(0, len(Parameters[0])): #Declare filenames MorphologyFileName = Path + "ShoreProfile_G1_T_" + str( Parameters[0][i]) + "_H_" + str(Parameters[1][i]) + "_W_" + str( Parameters[2][i]) + "_R_" + str( Parameters[3][i]) + "_Br_1_Bo_1.xz" ConcentrationsFileName = Path + "Concentrations_G1_T_" + str( Parameters[0][i]) + "_H_" + str(Parameters[1][i]) + "_W_" + str( Parameters[2][i]) + "_R_" + str( Parameters[3][i]) + "_Br_1_Bo_1.xn" #First plot the morphology through time # declare the file and the axis f = open(MorphologyFileName, 'r') Lines = f.readlines() NoLines = len(Lines) EndTime = float(Lines[-1].strip().split(" ")[0]) # Get info on vertical from header Header = np.array(Lines[0].strip().split(" "), dtype=np.float) CliffHeight = Header[0] dz = Header[1] Line = (Lines[-1].strip().split(" ")) Time = float(Line[0]) #Read morphology X = np.array(Line[1:], dtype="float64") + OffsetX[i] NValues = len(X) Z = np.arange(0, NValues) * -dz + CliffHeight + OffsetZ[i] #First plot the morphology through time # declare the file and the axis f = open(ConcentrationsFileName, 'r') Lines = f.readlines() NoLines = len(Lines) dx = float(Lines[1].strip().split()[0]) print dx #Read concentrations Line = (Lines[-1].strip().split(" ")) N = np.array(Line[1:], dtype="float64") + OffsetZ[i] * 1000 Xn = np.arange(0, len(N)) * dx + OffsetX[i] Mask = N != N[-1] N = N[Mask] Xn = Xn[Mask] ax1.plot(X, Z, 'k-', lw=1.5) ax1.plot([X[0], X[-1]], [OffsetZ[i], OffsetZ[i]], 'b-') ax2.plot(Xn, N, 'r-', lw=1.5) ax1.text( X[-1] + 20, Z[-1] - 12, ("Tr = " + str(Parameters[0][i]) + " m\n" + "H = " + str(Parameters[1][i]) + " m\n" + "W = " + str(Parameters[2][i]) + "\n" + "R = " + str(Parameters[3][i])), fontsize=8) # tweak the plot ax1.set_xlabel("Distance (m)") ax1.set_ylabel("Relative Elevation (m)") ax1.set_xlim(-100, 1100) ax1.set_ylim(-25, 150) ax2.set_ylim(-25000, 150000) ax2.set_ylabel("Relative Concentration (atoms g$^{-1}$)") plt.tight_layout() plt.savefig("CRN_ensemble.png") plt.savefig("CRN_ensemble.pdf")
x = time y = b_field_freq yerr = 1/np.sqrt(4*100) params = lmfit.Parameters() params.add('A', value = 0.5) params.add('freq', value = 1/(3600*12), vary = False) params.add('phase', value = 0.0) params.add('offset', value = 0.0) result = lmfit.minimize(cosine_fit, params, args = (x, y, yerr)) fit_values = y + result.residual lmfit.report_errors(params) x_plot = np.linspace(x.min(),x.max(),1000) figure = pyplot.figure(1) figure.clf() pyplot.plot(x,(b_field-np.average(b_field))*1000,'o') ax2 = pyplot.twinx() ax2.plot(x,b_field_freq*1000,'o', markersize = 0.0) ax2.plot(x_plot,cosine_model(params,x_plot)*1000,linewidth = 3.0) pyplot.show()
def create_plot_image(mark_inst, work_point=None): truncate_koef = 1.2 path1 = '/static/images/pq_and_eff.png' path2 = '/static/images/npsh.png' path3 = '/static/images/p2.png' curves = Curves(mark_inst, interplolate_curves=True) plt.clf() # clean plots # plot H-Q curve plt.plot(curves.q_points, curves.h_points) # plot workpoint and load H-Q curve if work_point: curves.compute_work_parameters(work_point) # plot work_point plt.plot(curves.work_point[0], curves.work_point[1], 'ro') if curves.q_wp: q_points = curves.q_points # compute index to truncate load curve i = 0 while q_points[i] < curves.q_wp: i += 1 i = round(i * truncate_koef) # plot curve truncated plt.plot(q_points[:i], curves.h_load_points[:i]) plt.plot(curves.q_wp, curves.h_wp, 'ro') # plot eff-Q curve ax_eff = plt.twinx() ax_eff.plot(curves.q_points, curves.eff_points) # get efficiency max value eff_max = max(curves.eff_points) # set plot y lim(it ax_eff.set_ylim((0, eff_max * 3)) plt.savefig('Main/' + path1) # plot npsh-Q curve plt.clf() plt.plot(curves.q_points, curves.npsh_points) plt.savefig('Main/' + path2) # plot p2-Q curve plt.clf() plt.plot(curves.q_points, curves.p2_points) plt.savefig('Main/' + path3) curves_data = {'img1': path1, 'img2': path2, 'img3': path3} if curves.q_wp != None: extra = { 'q_wp': formatted(curves.q_wp), 'h_wp': formatted(curves.h_wp), 'eff_wp': formatted(curves.eff_wp), 'npsh_wp': formatted(curves.npsh_wp), 'p2_wp': formatted(curves.p2_wp) } curves_data.update(extra) return curves_data