def run_method_usage(methods,cases): methods = [m[0] for m in methods] # Bootstrap the percentage error bars: percents =[] for i in range(10000): nc = resample(cases) percents.append(100*np.sum(nc,axis=0)/len(nc)) percents=np.array(percents) mean_percents = np.mean(percents,axis=0) std_percents = np.std(percents,axis=0)*1.96 inds=np.argsort(mean_percents).tolist() inds.reverse() avg_usage = np.mean(mean_percents) fig = plt.figure() ax = fig.add_subplot(111) x=np.arange(len(methods)) ax.plot(x,[avg_usage]*len(methods),'-',color='0.25',lw=1,alpha=0.2) ax.bar(x, mean_percents[inds], 0.6, color=paired[0],linewidth=0, yerr=std_percents[inds],ecolor=paired[1]) #ax.set_title('Method Occurrence') ax.set_ylabel('Occurrence %',fontsize=30) ax.set_xlabel('Method',fontsize=30) ax.set_xticks(np.arange(len(methods))) ax.set_xticklabels(np.array(methods)[inds],fontsize=8) fig.autofmt_xdate() fix_axes() plt.tight_layout() fig.savefig(figure_path+'method_occurrence.pdf', bbox_inches=0) fig.show() return inds,mean_percents[inds]
def do_plot_extras(self, extra): """ Plot other observed quantities as a function of time. Parameters ---------- extra: string One of the quantities available in system.extras """ # import pyqtgraph as pg colors = 'bgrcmykw' # lets hope for less than 9 data-sets t = self.time # handle inexistent field if extra not in self.extras._fields: from shell_colors import red msg = red('ERROR: ') + 'The name "%s" is not available in extras.\n' % extra clogger.fatal(msg) return i = self.extras._fields.index(extra) # index corresponding to this quantity plt.figure() # p = pg.plot() plt.plot(t, self.extras[i], 'o', label=extra) plt.xlabel('Time [days]') plt.ylabel(extra + ' []') plt.legend(loc='upper center', bbox_to_anchor=(0.5, 1.05)) plt.minorticks_on() plt.tight_layout() plt.show()
def _plot(self, doFAP=None): """ Create a plot. """ xlabel = 'Period [d]' ylabel = 'Power' self.fig = plt.figure() self.ax = self.fig.add_subplot(1,1,1) self.ax.set_title("Normalized periodogram") self.ax.set_xlabel(xlabel) self.ax.set_ylabel(ylabel) self.ax.semilogx(1./self.freq, self.power, 'b-') # plot FAPs if doFAP is None: pass elif doFAP is True: # do default FAPs of 10%, 1% and 0.1% pmin = 1./self.freq.min() pmax = 1./self.freq.max() plvl1 = self.powerLevel(0.1) # 10% FAP plvl2 = self.powerLevel(0.01) # 1% FAP plvl3 = self.powerLevel(0.001) # 0.1% FAP self.ax.semilogx([pmin, pmax],[plvl1, plvl1],'k-') self.ax.semilogx([pmin, pmax],[plvl2, plvl2],'k--') self.ax.semilogx([pmin, pmax],[plvl3, plvl3],'k:') plt.tight_layout() plt.show()
def do_plot_obs(self): """ Plot the observed radial velocities as a function of time. Data from each file are color coded and labeled. """ # import pyqtgraph as pg colors = 'bgrcmykw' # lets hope for less than 9 data-sets t, rv, err = self.time, self.vrad, self.error # temporaries plt.figure() # p = pg.plot() # plot each files' values for i, (fname, [n, nout]) in enumerate(sorted(self.provenance.iteritems())): m = n-nout # how many values are there after restriction # e = pg.ErrorBarItem(x=t[:m], y=rv[:m], \ # height=err[:m], beam=0.5,\ # pen=pg.mkPen(None)) # pen={'color': 0.8, 'width': 2}) # p.addItem(e) # p.plot(t[:m], rv[:m], symbol='o') plt.errorbar(t[:m], rv[:m], yerr=err[:m], \ fmt='o'+colors[i], label=fname) t, rv, err = t[m:], rv[m:], err[m:] plt.xlabel('Time [days]') plt.ylabel('RV [km/s]') plt.legend() plt.tight_layout() plt.show()
def save(self, plot_filename, max_col=2): fig = plt.figure() fig.suptitle(self.title, fontsize=8) if len(self.datastore) <= max_col: colsz = len(self.datastore) rowsz = 1 for i, d in enumerate(self.datastore): if len(d) == 0: continue # empty space ax = fig.add_subplot(rowsz, colsz, i + 1) self._plot(i, ax) else: sz = len(self.datastore) colsz = max_col rowsz = sz / max_col rowsz = rowsz if sz % max_col == 0 else rowsz + 1 for i, d in enumerate(self.datastore): if len(d) == 0: continue # empty space ax = fig.add_subplot(rowsz, colsz, i + 1) self._plot(i, ax) #plt.tight_layout(pad=0.4, w_pad=0.5, h_pad=1.0) plt.tight_layout() plt.savefig(plot_filename) return self
def plot_ss_scatter(steadies): """ Plot scatter plots of steady states """ def do_scatter(i, j, ax): """ Draw single scatter plot """ xs, ys = utils.extract(i, j, steadies) ax.scatter(xs, ys) ax.set_xlabel(r"$S_%d$" % i) ax.set_ylabel(r"$S_%d$" % j) cc = utils.get_correlation(xs, ys) ax.set_title(r"Corr: $%.2f$" % cc) dim = steadies.shape[1] fig, axarr = plt.subplots(1, int((dim ** 2 - dim) / 2), figsize=(20, 5)) axc = 0 for i in range(dim): for j in range(dim): if i == j: break do_scatter(i, j, axarr[axc]) axc += 1 plt.suptitle("Correlation overview") plt.tight_layout() save_figure("images/correlation_scatter.pdf", bbox_inches="tight") plt.close()
def plot(rho, u, uLB, tau, rho_history, zdjecia, image, nx, maxIter ): # plt.figure(figsize=(15,15)) # plt.subplot(4, 1, 1) # plt.imshow(u[1,:,0:50],vmin=-uLB*.15, vmax=uLB*.15, interpolation='none')#,cmap=cm.seismic # plt.colorbar() plt.rcParams["figure.figsize"] = (15,15) plt.subplot(5, 1, 1) plt.imshow(sqrt(u[0]**2+u[1]**2),vmin=0, vmax=uLB*1.6)#,cmap=cm.seismic plt.colorbar() plt.title('tau = {:f}'.format(tau)) plt.subplot(5, 1, 2) plt.imshow(u[0,:,:30], interpolation='none')#,cmap=cm.seismicvmax=uLB*1.6, plt.colorbar() plt.title('tau = {:f}'.format(tau)) plt.subplot(5, 1, 3) plt.imshow(rho, interpolation='none' )#,cmap=cm.seismic plt.title('rho') plt.subplot(5, 1,4) plt.title(' history rho') plt.plot(linspace(0,len(rho_history),len(rho_history)),rho_history) plt.xlim([0,maxIter]) plt.subplot(5, 1,5) plt.title(' u0 middle develop') plt.plot(linspace(0,nx,len(u[0,20,:])), u[1,20,:]) plt.tight_layout() plt.savefig(path.join(zdjecia,'f{0:06d}.png'.format(image))) plt.clf();
def plot_confusion_matrix(cm, title='', cmap=plt.cm.Blues): #print cm #display vehicle, idle, walking accuracy respectively #display overall accuracy print type(cm) # plt.figure(index plt.imshow(cm, interpolation='nearest', cmap=cmap) #plt.figure("") plt.title("Confusion Matrix") plt.colorbar() tick_marks = [0,1,2] target_name = ["driving","idling","walking"] plt.xticks(tick_marks,target_name,rotation=45) plt.yticks(tick_marks,target_name,rotation=45) print len(cm[0]) for i in range(0,3): for j in range(0,3): plt.text(i,j,str(cm[i,j])) plt.tight_layout() plt.ylabel("Actual Value") plt.xlabel("Predicted Outcome")
def plot_batch(color_model, q_ab, X_batch_black, X_batch_color, batch_size, h, w, nb_q, epoch): # Format X_colorized X_colorized = color_model.predict(X_batch_black / 100.)[:, :, :, :-1] X_colorized = X_colorized.reshape((batch_size * h * w, nb_q)) X_colorized = q_ab[np.argmax(X_colorized, 1)] X_a = X_colorized[:, 0].reshape((batch_size, 1, h, w)) X_b = X_colorized[:, 1].reshape((batch_size, 1, h, w)) X_colorized = np.concatenate((X_batch_black, X_a, X_b), axis=1).transpose(0, 2, 3, 1) X_colorized = [np.expand_dims(color.lab2rgb(im), 0) for im in X_colorized] X_colorized = np.concatenate(X_colorized, 0).transpose(0, 3, 1, 2) X_batch_color = [np.expand_dims(color.lab2rgb(im.transpose(1, 2, 0)), 0) for im in X_batch_color] X_batch_color = np.concatenate(X_batch_color, 0).transpose(0, 3, 1, 2) list_img = [] for i, img in enumerate(X_colorized[:min(32, batch_size)]): arr = np.concatenate([X_batch_color[i], np.repeat(X_batch_black[i] / 100., 3, axis=0), img], axis=2) list_img.append(arr) plt.figure(figsize=(20,20)) list_img = [np.concatenate(list_img[4 * i: 4 * (i + 1)], axis=2) for i in range(len(list_img) / 4)] arr = np.concatenate(list_img, axis=1) plt.imshow(arr.transpose(1,2,0)) ax = plt.gca() ax.get_xaxis().set_ticks([]) ax.get_yaxis().set_ticks([]) plt.tight_layout() plt.savefig("../../figures/fig_epoch%s.png" % epoch) plt.clf() plt.close()
def plot_ga_cnn(data, save=False, save_dest=None): plt.figure() # generation and all time best score plot # plt.subplot(211) # plt.title("GA CNN tuner on dataset D2") # plt.plot(data["dataset1"]["gen_best_score"], label="Generation Best") # plt.plot(data["dataset1"]["all_time_best_score"], label="All Time best") # plt.xlabel("Generation") # plt.ylabel("Score") # plt.xticks(range(0, 20)) # plt.xlim([0, 9]) # plt.ylim([0, 0.01]) # plt.legend(loc=0) # plt.subplot(212) # plt.title("GA CNN tuner on dataset D3") plt.plot(data["gen_best_score"], label="Generation Best") plt.plot(data["all_time_best_score"], label="All Time best") plt.xlabel("Generation") plt.ylabel("Score") plt.xticks(range(0, 20)) plt.xlim([0, 9]) plt.ylim([0, 0.01]) plt.legend(loc=0) # show plot or save as picture if save is False: plt.show() else: if save_dest is None: raise RuntimeError("save_dest not set!!") plt.tight_layout(pad=0.4, w_pad=0.5, h_pad=1.0) plt.savefig(save_dest, dpi=200)
def ACF_PACF_plot(self): #plot ACF and PACF to find the number of terms needed for the AR and MA in ARIMA # ACF finds MA(q): cut off after x lags # and PACF finds AR (p): cut off after y lags # in ARIMA(p,d,q) lag_acf = acf(self.ts_log_diff, nlags=20) lag_pacf = pacf(self.ts_log_diff, nlags=20, method='ols') #Plot ACF: ax=plt.subplot(121) plt.plot(lag_acf) ax.set_xlim([0,5]) plt.axhline(y=0,linestyle='--',color='gray') plt.axhline(y= -1.96/np.sqrt(len(ts_log_diff)),linestyle='--',color='gray') plt.axhline(y= 1.96/np.sqrt(len(ts_log_diff)),linestyle='--',color='gray') plt.title('Autocorrelation Function') #Plot PACF: plt.subplot(122) plt.plot(lag_pacf) plt.axhline(y=0,linestyle='--',color='gray') plt.axhline(y= -1.96/np.sqrt(len(ts_log_diff)),linestyle='--',color='gray') plt.axhline(y=1.96/np.sqrt(len(ts_log_diff)),linestyle='--',color='gray') plt.title('Partial Autocorrelation Function') plt.tight_layout()
def plotRttDistribution(rttEstimates, ip, filename, nbBins=500, logscale=False): """Plot the RTT distribution of an IP address :rttEstimates: pandas DataFrame containing the RTT estimations :ip: IP address to plot :filename: Filename for the plot :nbBins: Number of bins in the histogram :logscale: Plot RTTs in logscale if set to True :returns: None """ if logscale: data = np.log10(rttEstimates[rttEstimates.index == ip].rtt) else: data = rttEstimates[rttEstimates.index == ip].rtt h, b=np.histogram(data, nbBins, normed=True) plt.figure(1, figsize=(9, 3)) plt.clf() ax = plt.subplot() x = b[:-1] ax.plot(x, h, "k") ax.grid(True) plt.title("%s (%s RTTs)" % (ip, len(data))) if logscale: plt.xlabel("log10(RTT)") else: plt.xlabel("RTT") plt.ylabel("pdf") minorLocator = mpl.ticker.MultipleLocator(10) ax.xaxis.set_minor_locator(minorLocator) plt.tight_layout() plt.savefig(filename)
def test(args): data = multivariate_normal([0, 0], [[1, 2], [2, 5]], int(args[1])) print(data) # PCA result = pca(data, base_num=int(args[2])) pc_base = result[0] print(pc_base) # Plotting fig = plt.figure() fig.add_subplot(1, 1, 1) plt.axvline(x=0, color="#000000") plt.axhline(y=0, color="#000000") # Plot data plt.scatter(data[:, 0], data[:, 1]) # Draw the 1st principal axis pc_line = sp.array([-3.0, 3.0]) * (pc_base[1] / pc_base[0]) plt.arrow(0, 0, -pc_base[0] * 2, -pc_base[1] * 2, fc="r", width=0.15, head_width=0.45) plt.plot([-3, 3], pc_line, "r") # Settings plt.xticks(size=15) plt.yticks(size=15) plt.xlim([-3, 3]) plt.tight_layout() plt.show() plt.savefig("image.png") return 0
def plot_corner_posteriors(self, savefile=None, labels=["T1", "R1", "Av", "T2", "R2"]): ''' Plots the corner plot of the MCMC results. ''' ndim = len(self.sampler.flatchain[0,:]) chain = self.sampler samples = chain.flatchain samples = samples[:,0:ndim] plt.figure(figsize=(8,8)) fig = corner.corner(samples, labels=labels[0:ndim]) plt.title("MJD: %.2f"%self.mjd) name = self._get_save_path(savefile, "mcmc_posteriors") plt.savefig(name) plt.close("all") plt.figure(figsize=(8,ndim*3)) for n in range(ndim): plt.subplot(ndim,1,n+1) chain = self.sampler.chain[:,:,n] nwalk, nit = chain.shape for i in np.arange(nwalk): plt.plot(chain[i], lw=0.1) plt.ylabel(labels[n]) plt.xlabel("Iteration") name_walkers = self._get_save_path(savefile, "mcmc_walkers") plt.tight_layout() plt.savefig(name_walkers) plt.close("all")
def PSTH(self): TimeRes = np.array([0.1,0.25,0.5,1,2.5,5.0,10.0,25.0,50.0,100.0]) Projection_PSTH = np.zeros((2,len(TimeRes))) for i in range(0,len(TimeRes)): Data_Hist,STA_Hist,Model_Hist,B = Hist(TimeRes[i]) data = Data_Hist/np.linalg.norm(Data_Hist) sta = STA_Hist/np.linalg.norm(STA_Hist) model = Model_Hist/np.linalg.norm(Model_Hist) Projection_PSTH[0,i] = np.dot(data,sta) Projection_PSTH[1,i] = np.dot(data,model) import matplotlib.font_manager as fm plt.figure() plt.semilogx(TimeRes,Projection_PSTH[0,:],'gray',TimeRes,Projection_PSTH[1,:],'k', linewidth=3, marker='o', markersize = 12) plt.xlabel('Time Resolution, ms',fontsize=25) plt.xticks(fontsize=25) #plt.axis["right"].set_visible(False) plt.ylabel('Projection onto PSTH',fontsize=25) plt.yticks(fontsize=25) prop = fm.FontProperties(size=20) plt.legend(('1D model','2D model'),loc='upper left',prop=prop) plt.tight_layout() plt.show()
def plot_graph(self): ''' plots a matplotlib graph from the stocks data. Dates on the x axis and Closing Prices on the y axis. Then adds it to the graph_win in the display frame as a tk widget() ''' x_axis = [ dt.datetime.strptime(self.daily_data[day][0], '%Y-%m-%d') for day in range(1, len(self.daily_data) - 1) ] y_axis = [ self.daily_data[cls_adj][-1] for cls_adj in range(1, len(self.daily_data) - 1) ] fig = plt.figure() ax = fig.add_subplot("111") ax.plot( x_axis, y_axis, marker='h', linestyle='-.', color='r', label='Daily Adjusted Closing Prices' ) labels = ax.get_xticklabels() for label in labels: label.set_rotation(15) plt.xlabel('Dates') plt.ylabel('Close Adj') plt.legend() plt.tight_layout() # adjusts the graph to fit in the space its limited to self.data_plot = FigureCanvasTkAgg(fig, master=self.display) self.data_plot.show() self.graph_win = self.data_plot.get_tk_widget()
def behavioral_analysis(self): """some analysis of the behavioral data, such as mean percept duration, dominance ratio etc""" self.assert_data_intern() # only do anything if this is not a no report trial if 'RP' in self.file_alias: all_percepts_and_durations = [[],[]] else: all_percepts_and_durations = [[],[],[]] if not 'NR' in self.file_alias: # and not 'RP' in self.file_alias for x in range(len(self.trial_indices)): if len(self.events) != 0: events_this_trial = self.events[(self.events['EL_timestamp'] > self.timestamps_pt[x][0]) & (self.events['EL_timestamp'] < self.timestamps_pt[x][-1])] for sc, scancode in enumerate(self.scancode_list): percept_start_indices = np.arange(len(events_this_trial))[np.array(events_this_trial['scancode'] == scancode)] percept_end_indices = percept_start_indices + 1 # convert to times start_times = np.array(events_this_trial['EL_timestamp'])[percept_start_indices] - self.timestamps_pt[x,0] if len(start_times) > 0: if percept_end_indices[-1] == len(events_this_trial): end_times = np.array(events_this_trial['EL_timestamp'])[percept_end_indices[:-1]] - self.timestamps_pt[x,0] end_times = np.r_[end_times, len(self.from_zero_timepoints)] else: end_times = np.array(events_this_trial['EL_timestamp'])[percept_end_indices] - self.timestamps_pt[x,0] these_raw_event_times = np.array([start_times + self.timestamps_pt[x,0], end_times + self.timestamps_pt[x,0]]).T these_event_times = np.array([start_times, end_times]).T + x * self.trial_duration * self.sample_rate durations = np.diff(these_event_times, axis = -1) all_percepts_and_durations[sc].append(np.hstack((these_raw_event_times, these_event_times, durations))) self.all_percepts_and_durations = [np.vstack(apd) for apd in all_percepts_and_durations] # last element is duration, sum inclusive and exclusive of transitions total_percept_duration = np.concatenate([apd[:,-1] for apd in self.all_percepts_and_durations]).sum() total_percept_duration_excl = np.concatenate([apd[:,-1] for apd in [self.all_percepts_and_durations[0], self.all_percepts_and_durations[-1]]]).sum() self.ratio_transition = 1.0 - (total_percept_duration_excl / total_percept_duration) self.ratio_percept_red = self.all_percepts_and_durations[0][:,-1].sum() / total_percept_duration_excl self.red_durations = np.array([np.mean(self.all_percepts_and_durations[0][:,-1]), np.median(self.all_percepts_and_durations[0][:,-1])]) self.green_durations = np.array([np.mean(self.all_percepts_and_durations[-1][:,-1]), np.median(self.all_percepts_and_durations[-1][:,-1])]) self.transition_durations = np.array([np.mean(self.all_percepts_and_durations[1][:,-1]), np.median(self.all_percepts_and_durations[1][:,-1])]) self.ratio_percept_red_durations = self.red_durations / (self.red_durations + self.green_durations) plot_mean_or_median = 0 # mean f = pl.figure(figsize = (8,4)) s = f.add_subplot(111) for i in range(len(self.colors)): pl.hist(self.all_percepts_and_durations[i][:,-1], bins = 20, color = self.colors[i], histtype='step', lw = 3.0, alpha = 0.4, label = ['Red', 'Trans', 'Green'][i]) pl.hist(np.concatenate([self.all_percepts_and_durations[0][:,-1], self.all_percepts_and_durations[-1][:,-1]]), bins = 20, color = 'k', histtype='step', lw = 3.0, alpha = 0.4, label = 'Percepts') pl.legend() s.set_xlabel('time [ms]') s.set_ylabel('count') sn.despine(offset=10) s.annotate("""ratio_transition: %1.2f, \nratio_percept_red: %1.2f, \nduration_red: %2.2f,\nduration_green: %2.2f, \nratio_percept_red_durations: %1.2f"""%(self.ratio_transition, self.ratio_percept_red, self.red_durations[plot_mean_or_median], self.green_durations[plot_mean_or_median], self.ratio_percept_red_durations[plot_mean_or_median]), (0.5,0.65), textcoords = 'figure fraction') pl.tight_layout() pl.savefig(os.path.join(self.analyzer.fig_dir, self.file_alias + '_dur_hist.pdf'))
def plot_abc(self, uarg, param): """Plot a() and b() functions on the same plot. """ plt.figure(figsize=(8, 4)) plt.subplot(1, 3, 1) plt.plot(uarg, self.afun(uarg, param)) plt.axhline(0) plt.axvline(0) plt.ylabel('$a(u)$') plt.xlabel('$u$') plt.subplot(1, 3, 2) plt.plot(uarg, self.bfun(uarg, param)) plt.axhline(0) plt.axvline(0) plt.ylabel('$b(u)$') plt.xlabel('$u$') plt.subplot(1, 3, 3) plt.plot(uarg, self.cfun(uarg, param)) plt.axhline(0) plt.axvline(0) plt.ylabel('$c(u)$') plt.xlabel('$u$') plt.tight_layout() plt.show()
def plmyfig(df, bgname, dirname, tar, count=10): #plot fig! print("Starting Plot %s %s" % (dirname, bgname)) if len(df) > count: df = df.head(count) pos = plt.arange(len(df)) + 0.5 ytick = _getTerm(df['Term_description'], df['Term_ID'], bgname) xs = [float(n) for n in df[' -log10(pvalue)']] ytick.reverse() xs.reverse() plt.barh(pos, xs, align = 'center', height = 0.5, alpha = 1, color='orange') plt.yticks(pos, ytick, size = 'x-small') plt.xlabel('$-Log10(pValue)$') plt.title('%s' % bgname) ax = plt.gca() ax.spines['right'].set_visible(False) ax.spines['top'].set_visible(False) ax.yaxis.set_ticks_position('left') ax.xaxis.set_ticks_position('bottom') try: plt.tight_layout() except ValueError: pass filename = os.path.join(tar, dirname, dirname + '_' + bgname) plt.savefig(filename + '.png', dpi = 72) plt.savefig(filename + '.pdf') plt.close()
def plot(self,file): cds = CaseDataset(file, 'bson') data = cds.data.driver('driver').by_variable().fetch() cds2 = CaseDataset('../output/therm_mc_20141110173851.bson', 'bson') data2 = cds2.data.driver('driver').by_variable().fetch() #temp temp_boundary_k = data['hyperloop.temp_boundary'] temp_boundary_k.extend(data2['hyperloop.temp_boundary']) temp_boundary = [((x-273.15)*1.8 + 32) for x in temp_boundary_k] #histogram n, bins, patches = plt.hist(temp_boundary, 100, normed=1, histtype='stepfilled') plt.setp(patches, 'facecolor', 'b', 'alpha', 0.75) #stats mean = np.average(temp_boundary) std = np.std(temp_boundary) percentile = np.percentile(temp_boundary,99.5) print "mean: ", mean, " std: ", std, " 99.5percentile: ", percentile x = np.linspace(50,170,150) plt.plot(x,mlab.normpdf(x,mean,std), color='black', lw=2) plt.xlim([60,160]) plt.ylabel('Probability', fontsize=18) plt.xlabel(u'Equilibrium Temperature, \N{DEGREE SIGN}F', fontsize=18) #plt.show() plt.tight_layout() plt.savefig('../output/histo.pdf', dpi=300)
def plot_reconstruction_result(res): """ Plot original and reconstructed graph plus time series """ fig = plt.figure(figsize=(32, 8)) gs = mpl.gridspec.GridSpec(1, 4) # original graph orig_ax = plt.subplot(gs[0]) plot_graph(nx.from_numpy_matrix(res.A.orig), orig_ax) orig_ax.set_title('Original graph') # time series ax = plt.subplot(gs[1:3]) sns.tsplot( time='time', value='theta', unit='source', condition='oscillator', estimator=np.mean, legend=False, data=compute_solutions(res), ax=ax) ax.set_title(r'$A_{{err}} = {:.2}, B_{{err}} = {:.2}$'.format(*compute_error(res))) # reconstructed graph rec_ax = plt.subplot(gs[3]) tmp = res.A.rec tmp[abs(tmp) < 1e-1] = 0 plot_graph(nx.from_numpy_matrix(tmp), rec_ax) rec_ax.set_title('Reconstructed graph') plt.tight_layout() save(fig, 'reconstruction_overview')
def save(self, out_path): '''Saves a figure for the monitor Args: out_path: str ''' plt.clf() np.set_printoptions(precision=4) font = { 'size': 7 } matplotlib.rc('font', **font) y = 2 x = ((len(self.d) - 1) // y) + 1 fig, axes = plt.subplots(y, x) fig.set_size_inches(20, 8) for j, (k, v) in enumerate(self.d.iteritems()): ax = axes[j // x, j % x] ax.plot(v, label=k) if k in self.d_valid.keys(): ax.plot(self.d_valid[k], label=k + '(valid)') ax.set_title(k) ax.legend() plt.tight_layout() plt.savefig(out_path, facecolor=(1, 1, 1)) plt.close()
def plot(self, show=True, filename=None): """ Plots the windows for the object's channel. :param show: Calls ``plt.show()`` before returning if True. :param filename: If given, a picture will be saved to this path. :return: The possibly created axes object. """ if self.comm is None: raise ValueError("Operation only possible with an active " "communicator instance.") import matplotlib.pylab as plt ax = self.comm.visualizations.plot_data_and_synthetics( self.event, self.iteration, self.channel_id, show=False) ylim = ax.get_ylim() st = self.event["origin_time"] for window in self.windows: ax.fill_between((window.starttime - st, window.endtime - st), [ylim[0] - 10] * 2, [ylim[1] + 10] * 2, alpha=0.3, lw=0, zorder=-10) ax.set_ylim(*ylim) if show: plt.tight_layout() plt.show() plt.close() elif filename: plt.tight_layout() plt.savefig(filename) plt.close() return ax
def zsview(im, cmap=pl.cm.gray, figsize=(8,5), contours=False, ccolor='r'): z1, z2 = zscale(im) pl.figure(figsize=figsize) pl.imshow(im, vmin=z1, vmax=z2, origin='lower', cmap=cmap, interpolation='none') if contours: pl.contour(im, levels=[z2], origin='lower', colors=ccolor) pl.tight_layout()
def expt3(): """ Experiment 2: Chooses the result files and generates figures """ result_file = "./expt3.txt" input_threads, input_sizes, throughputs, resp_times \ = parse_output(result_file) throughputs_MiB = [tp/2**20 for tp in throughputs] fig1, (ax0, ax1) = pl.subplots(ncols=2, figsize=(6, 3)) fig1.set_tight_layout(True) ax0.plot(input_threads, throughputs_MiB, 'bo-', ms=MARKER_SIZE, mew=0, mec='b') ax0.set_xlabel("threads") ax0.set_ylabel("throughput (MiB/sec)") ax0.set_xlim(0,25) ax0.text(1, 85, "(A)") ax1.plot(input_threads, resp_times, 'mo-', ms=MARKER_SIZE, mew=0, mec='m') ax1.set_xlabel("threads") ax1.set_ylabel("response time (sec)") ax1.set_xlim(0,25) ax1.set_ylim(0,400) ax1.text(1, 375, "(B)") pl.tight_layout() pl.savefig("./figures/%s" % result_file.replace(".txt", ".pdf"))
def plot_ra(s1, s2, idxs=None, epsilon=0.25, fig=None): """Computes the RA plot of two groups of samples""" ## compute log2 values l1 = np.log2(s1 + epsilon) l2 = np.log2(s2 + epsilon) ## compute A and R r = l1 - l2 a = (l1 + l2) * 0.5 fig = pl.figure() if fig is None else fig pl.figure(fig.number) if idxs is None: pl.plot(a, r, '.k', markersize=2) else: pl.plot(a[~idxs], r[~idxs], '.k', markersize=2) pl.plot(a[idxs], r[idxs], '.r') pl.axhline(0, linestyle='--', color='k') pl.xlabel('(log2 sample1 + log2 sample2) / 2') pl.ylabel('log2 sample1 - log2 sample2') pl.tight_layout()
def test_pix_positions(self): image.sex(os.path.join(self.args.output_path, 'output.fits')) inputcat=catalog.read(os.path.join(self.args.tmp_path, 'ccd_1.cat')) outputcat=catalog.readfits(os.path.join(self.args.output_path, 'output.cat')) ouputcat=outputcat[outputcat["FLAGS"]==0] mergedcat=catalog.mergecatpix(inputcat,outputcat, delta=3, poskeys1=['X_IMAGE','Y_IMAGE'], poskeys2=['X_IMAGE','Y_IMAGE']) catalog.add_diff_column(mergedcat,'X_IMAGE_2','X_IMAGE_1',outputfield='DELTAX') catalog.add_diff_column(mergedcat,'Y_IMAGE_2','Y_IMAGE_1',outputfield='DELTAY') #p.figure() #p.scatter(mergedcat['DELTAX'],mergedcat['DELTAY']) #p.xlabel('Delta X (pixels)') #p.ylabel('Delta Y (pixels)') catalog.scattercols(mergedcat,'DELTAX','DELTAY',xlab='Delta X (pixels)',ylab='Delta Y (pixels)',show=False) p.grid() p.legend() p.tight_layout() p.savefig(os.path.join(self.figdir,"wcs_test_pix_positions_1.png")) p.figure() f, axarr = p.subplots(2, sharex=True) axarr[0].hist(mergedcat['DELTAX'],bins=np.linspace(-0.5,0.5,101)) axarr[0].set_title('Delta X (pixels)') axarr[1].hist(mergedcat['DELTAY'],bins=np.linspace(-0.5,0.5,101)) axarr[1].set_title('Delta Y (pixels)') p.grid() p.legend() p.tight_layout() p.savefig(os.path.join(self.figdir,"wcs_test_pix_positions_2.png")) tol = 0.15 assert (np.mean(mergedcat['DELTAX']) < tol) and (np.mean(mergedcat['DELTAY']) < tol)
def plot_data(self,full_fname=None, dpi=300, ys=None, yhat=None): name = self.test_name if ys is not None : ys_data = ys else : ys_data = self.results.series[name]['ys'] if yhat is not None : yhat_data = yhat else: yhat_data = self.results.series[name]['yhat'] fig = plt.figure() ax = fig.add_subplot(111) plt.plot(ys_data) plt.plot(yhat_data) if ys is None : fig.suptitle("%s | wp:%s,lc:%s" % (name,self.tm.winners_percent,self.tm.loopy_cols)) y = 0.998 for m in ['mape','nll', 'mae', 'rmse', 'r2'] : metric = "%s: %.3f" % (str(m).upper(), self.results.metrics[name][m]) plt.text(0.998,y, metric, horizontalalignment='right', verticalalignment='top', transform=ax.transAxes) y -= 0.03 plt.tight_layout() if full_fname is not None : fig.savefig(full_fname,bbox_inches='tight',dpi=dpi) plt.close(fig)
def measure_psf(vignet, pixscale=1., show=False, mask_value=None): y, x = np.mgrid[-vignet.shape[0]/2:vignet.shape[0]/2, -vignet.shape[1]/2:vignet.shape[1]/2]*pixscale if mask_value : vignet = ma.masked_values(vignet, mask_value).filled(0) # Fit the data using astropy.modeling p_init=models.Gaussian2D(amplitude=vignet.max(), x_mean=0., y_mean=0., x_stddev=2*pixscale, y_stddev=2*pixscale, theta=0, cov_matrix=None) fit_p = fitting.LevMarLSQFitter() p = fit_p(p_init, x, y, vignet) barycenter=measure_barycenter(vignet, pixscale=pixscale) # Plot the data with the best-fit model P.figure(figsize=(8, 2.5)) P.subplot(1, 3, 1) P.imshow(vignet, origin='lower', interpolation='nearest', vmin=vignet.min(), vmax=vignet.max()) P.title("Data") P.subplot(1, 3, 2) P.imshow(p(x, y), origin='lower', interpolation='nearest', vmin=vignet.min(), vmax=vignet.max()) P.scatter(vignet.shape[0]/2, vignet.shape[1]/2,marker="+") P.annotate("({:.3f},{:.3f})".format(*barycenter), (vignet.shape[0]/3, vignet.shape[1]/3)) P.title("Model - psf = {:.2f}".format(2.3548*np.mean([p.x_stddev.value, p.y_stddev.value]))) P.subplot(1, 3, 3) P.imshow(vignet - p(x, y), origin='lower', interpolation='nearest', vmin=-vignet.max()/10,vmax=vignet.max()/10) P.title("Residual") P.tight_layout() if show : P.show() return p
def plot_fitted_model(self, sample, data, fig=None, xmin=-1, xmax=12, npoints=1000, nbins=100, epsilon=0.25): """Plot fitted model""" # fetch group group = [i for i, item in enumerate(data.groups.items()) if sample in item[1]][0] # fetch data counts = data.counts_norm[sample].values.astype('float') counts[counts < 1] = epsilon counts = np.log(counts) # compute fitted model x = np.reshape(np.linspace(xmin, xmax, npoints), (-1, 1)) xx = np.exp(x) loglik = _compute_loglik(xx, self.log_phi, self.log_mu, self.beta[self.z[group]]) y = xx * np.exp(loglik) / self.nfeatures # plot fig = pl.figure() if fig is None else fig pl.figure(fig.number) pl.hist(counts, nbins, histtype='stepfilled', linewidth=0, normed=True, color='gray') pl.plot(x, np.sum(y, 1), 'r') pl.grid() pl.xlabel('log counts') pl.ylabel('density') pl.legend(['model', 'data'], loc=0) pl.tight_layout()
def plot(self, **kwargs): """ plot artifact rejection averaged signals for ECG and EOG onsets Parameters ---------- raw : raw_clean : ch_name : events : event_id : picks : tmin : tmax : title : colors : alpha : grid : scale : offset : fontsize : Returns ------- """ self._update_from_kwargs(**kwargs) title = kwargs.get("title") evt = kwargs.get("events") counts = evt.shape[0] # init figure sig_raw, sig_clean, range, t = self._calc_data(self.raw, self.raw_clean, evt, event_id=self.event_id, tmin=self.tmin, tmax=self.tmax, picks=self.picks) #--- ref channel e.g.: ECG sig_picks = self.labels2picks(labels=self.ch_name) sig_ref, _, _ = self._calc_signal(self.raw, evt, event_id=self.event_id, tmin=self.tmin, tmax=self.tmax, picks=sig_picks) if not isinstance(self.figures, (list)): self.figures = [] # if self.idx == 1: if not self._fig: self.figures.append(plt.figure(self.fig_nr)) self._fig = self.figures[-1] if title: self.figure.suptitle(title, fontsize=12) suptitle = kwargs.get("suptitle") self.suptitle = suptitle else: self._fig = plt.figure(self.fig_nr) #--- subplot(nrows,ncols,idx) ax1 = plt.subplot(self.n_rows, self.n_cols, self.idx) #--- sig raw scl = self.scale.get("raw") ylim = self._calc_ylimits(ranges=range, factor=scl.get("factor"), offset=self.offset) self._plot(ax1, t, sig_raw * scl.get("factor"), scl.get("unit"), "black") #--- sig clean ax2 = plt.subplot(self.n_rows, self.n_cols, self.idx + self.n_cols) self._plot(ax2, t, sig_clean * scl.get("factor"), scl.get("unit"), "black") #--- scl = self.scale.get("ref") ax3 = ax1.twinx( ) # instantiate a second axes that shares the same x-axis color = 'tab:blue' self._plot(ax3, t, sig_ref * scl.get("factor"), scl.get("unit"), "red") ax3.tick_params(axis='y', labelcolor=color) ax3.legend([self.ch_name + " cnts {}".format(counts)], loc=2, prop={'size': 8}) ax4 = ax2.twinx( ) # instantiate a second axes that shares the same x-axis color = 'tab:blue' self._plot(ax4, t, sig_ref * scl.get("factor"), scl.get("unit"), "green") ax4.tick_params(axis='y', labelcolor=color) ax4.legend(["Clean " + self.ch_name + " cnts {}".format(counts)], loc=2, prop={'size': 8}) try: ax1.set_ylim(ylim[0], ylim[1]) ax2.set_ylim(ylim[0], ylim[1]) except: ax1.set_ylim(-1.0, 1.0) ax2.set_ylim(-1.0, 1.0) logger.error( "ERROR in performance plot : can not set ylim : {}".format( title)) plt.tight_layout()
def sample_of_trajectories(model, path, agent_ids=range(100), secveg_dynamics=False): fig, (ax1, ax2, ax3) = plt.subplots(3, sharex='all', figsize=(6, 6)) ax1b = ax2.twinx() if agent_ids == "all": agent_ids = range(model.no_agents) for inspect_id in agent_ids: print("plotting trajectory %d" % inspect_id ) # print(sv_traj[0:dim]) plot_P, plot_qp, plot_k, plot_F, plot_S, plot_qs, *aux_vars = np.copy( model.sv_traj.T[inspect_id * model.dim:(inspect_id + 1) * model.dim]) ax1.plot(model.t, plot_F, color='darkgreen', linewidth=.5, label='F', alpha=0.3) ax1.plot(model.t, plot_P, color='lawngreen', linewidth=.5, label='P', alpha=0.3) ax1.plot(model.t, plot_S, color='m', linewidth=.5, label='S', alpha=0.3) ax2.plot(model.t, plot_qp, color='saddlebrown', linewidth=.5, label='q', alpha=0.3) if secveg_dynamics: ax2.plot(model.t, plot_qs, color='m', linewidth=.5, label=r'qs', alpha=0.3) ax1b.plot(model.t, plot_k, 'b', linewidth=.5, label=r'$k$', alpha=0.3) # , marker='o', fillstyle = 'none') plot_d, plot_a, plot_r, plot_l, plot_m = np.copy( model.cv_traj.T[inspect_id * model.no_controls:(inspect_id + 1) * model.no_controls]) ax3.plot(model.t, plot_d, label='d', color='b', linewidth=.5, alpha=0.3) ax3.plot(model.t, plot_a, label='a', color='r', linewidth=.5, alpha=0.3) ax3.plot(model.t, plot_r, label='r', color='g', linewidth=.5, alpha=0.3) ax3.plot(model.t, plot_l, label='l', color='m', linewidth=.5, alpha=0.3) ax3.plot(model.t, plot_m, label='m', color='c', linewidth=.5, alpha=0.3) ax1.set_ylabel(r'$F, P, S$', fontsize=16) if not model.pars["absolute_area"]: ax1.set_ylim([-0.1, 1.1]) handles, labels = ax1.get_legend_handles_labels() ax1.legend(handles[0:3], labels[0:3], loc='upper left') ax2.set_ylabel(r'$q$', fontsize=16, color='saddlebrown') for tl in ax2.get_yticklabels(): tl.set_color('saddlebrown') ax1b.set_ylabel(r'$k$', color='b', fontsize=16) for tick_label in ax1b.get_yticklabels(): tick_label.set_color('b') ax3.set_xlabel(r't', fontsize=16) ax3.set_ylim([-0.2, 1]) handles, labels = ax3.get_legend_handles_labels() ax3.legend(handles[0:5], labels[0:5], loc='upper left') ax3.text(-1., -0.1, 'strategy', horizontalalignment='right', verticalalignment='center') plt.tight_layout() fig.savefig(path, dpi=model.plot_pars["dpi_saving"]) fig.clf() plt.close(fig) return 0
def plot_single_agent(model, path, node_id=1, plot_areas=True, plot_qk=True, plot_controls=False, plot_aux=False, secveg_dynamics=False, ): axis_label_fontsize = 14 # print(sv_traj[0:dim]) plot_p, plot_qp, plot_k, plot_f, plot_s, plot_qs, *aux_vars = np.copy(model.sv_traj.T[node_id * model.dim:(node_id + 1) * model.dim]) no_plots = sum([plot_areas, plot_qk, plot_controls, plot_aux]) fig, ax = plt.subplots(no_plots, sharex='all', figsize=(6, no_plots * 2 + 1)) if no_plots == 1: ax = [ax] # current axis axis_counter = 0 # plot labels plot_labels = ["(a)", "(b)", "(c)", "(d)", "(e)", "(f)"] annotation_pos = (-0.15, 1) annotation_offset = (1, -1) if plot_areas: cax = ax[axis_counter] cax.plot(model.t, plot_f, color='darkgreen', linewidth=2., label='Forest F') cax.plot(model.t, plot_p, color='lawngreen', linewidth=2., label='Pasture P') cax.plot(model.t, plot_s, color='m', linewidth=2., label='Sec. Vegetation S') cax.set_ylabel(r'$F, P, S$ [ha]', fontsize=axis_label_fontsize) if not model.pars["absolute_area"]: cax.set_ylim([-0.1, 1.1]) cax.legend(loc='right') cax.annotate(plot_labels[axis_counter], xy=annotation_pos, xycoords='axes fraction', fontsize=axis_label_fontsize, xytext=annotation_offset, textcoords='offset points', horizontalalignment='left', verticalalignment='top') axis_counter += 1 if plot_qk: cax = ax[axis_counter] cax.plot(model.t, plot_qp, color='saddlebrown', linewidth=2., label='pasture productivity q') if secveg_dynamics: cax.plot(model.t, plot_qs, color='m', linewidth=2., label='soil quality (on S) v') if secveg_dynamics: cax.set_ylabel(r'$q, v$ [a.u.]', fontsize=axis_label_fontsize, color='k') else: cax.set_ylabel(r'$q$ [a.u.]', fontsize=axis_label_fontsize, color='saddlebrown') for tl in cax.get_yticklabels(): tl.set_color('saddlebrown') #cax.set_zorder(100) axt = cax.twinx() if max(plot_k) > 10000000: rescale_k = 1000000 elif max(plot_k) > 10000: rescale_k = 1000 else: rescale_k = 1 axt.plot(model.t, plot_k/rescale_k, 'b', linewidth=2., label=r'savings $k$') # , marker='o', fillstyle = 'none') if rescale_k == 1: axt.set_ylabel(r'savings [BRL]', color='b', fontsize=axis_label_fontsize) else: axt.set_ylabel(r'savings [{} BRL]'.format(rescale_k), color='b', fontsize=axis_label_fontsize) for tick_label in axt.get_yticklabels(): tick_label.set_color('b') if secveg_dynamics: cax.legend(loc='lower right') # loc='upper/lower right' cax.annotate(plot_labels[axis_counter], xy=annotation_pos, xycoords='axes fraction', fontsize=axis_label_fontsize, xytext=annotation_offset, textcoords='offset points', horizontalalignment='left', verticalalignment='top') axis_counter += 1 if plot_controls: cax = ax[axis_counter] plot_d, plot_a, plot_r, plot_l, plot_m = np.copy(model.cv_traj.T[node_id * model.no_controls:(node_id + 1) * model.no_controls]) cax.plot(model.t, plot_d, label='d', color='b') cax.plot(model.t, plot_a, label='a', color='r') cax.plot(model.t, plot_r, label='r', color='g') cax.plot(model.t, plot_l, label='l', color='m') cax.plot(model.t, plot_m, label='m', color='c') max_plot = np.array([plot_d, plot_a, plot_r, plot_l, plot_m]).max().max() cax.set_ylim([-0.2*max_plot, 1.1 * max_plot]) # print(strategy_traj.T[inspect_id]) # visualize strategy for i, strategy_t in enumerate(model.strategy_traj.T[node_id]): if strategy_t == 0: color = 'g' else: color = 'r' cax.plot((i - 0.5, i + 0.5), (-0.1*max_plot, -0.1*max_plot), linewidth=10, color=color, solid_capstyle='butt') cax.legend(loc='upper right') cax.text(-1., -0.1*max_plot, 'strategy', horizontalalignment='right', verticalalignment='center') cax.annotate(plot_labels[axis_counter], xy=annotation_pos, xycoords='axes fraction', fontsize=axis_label_fontsize, xytext=annotation_offset, textcoords='offset points', horizontalalignment='left', verticalalignment='top') axis_counter += 1 if plot_aux: cax = ax[axis_counter] for i, aux_var in enumerate(aux_vars): cax.plot(model.t, aux_var, label=model.state_variables[model.dim - model.no_aux_vars + i]) cax.legend(loc='upper right') cax.annotate(plot_labels[axis_counter], xy=annotation_pos, xycoords='axes fraction', fontsize=axis_label_fontsize, xytext=annotation_offset, textcoords='offset points', horizontalalignment='left', verticalalignment='top') axis_counter += 1 cax.set_xlabel(r'time [years]', fontsize=axis_label_fontsize) plt.tight_layout() fig.savefig(path, dpi=model.plot_pars["dpi_saving"]) fig.clf() plt.close(fig) return 0
def plot_trajectory_stat( stats_df, path, measure="median", bounds=None, percentiles=None, plot_areas=True, plot_controls=False, plot_strategy=True, plot_active_ranches=False, plot_qk=True, plot_price=False, plot_gini=False, secveg_dynamics=False, t_min=None, dpi=150, ensemble_stats=False): axis_label_fontsize = 14 # show also standard deviation/percentiles of aggregate variables # with the following alpha range_alpha = 0.2 t = stats_df.index.values if t_min is None: t_min = min(t) t_max = max(t) t = t[t_min:t_max] no_plots = sum([plot_areas, plot_controls, plot_strategy, plot_qk, plot_price, plot_gini]) fig, ax = plt.subplots(no_plots, sharex='all', figsize=(6, no_plots * 2 + 1)) # plot labels plot_labels = ["(a)", "(b)", "(c)", "(d)", "(e)", "(f)"] annotation_pos = (-0.19, 1) annotation_offset = (1, -1) # current axis axis_counter = 0 if bounds is 'percentiles': if type(percentiles) is not list: print("Error: Need percentiles for plotting!") return 1 lb_label = "perc" + str(percentiles[0]) ub_label = "perc" + str(percentiles[1]) elif bounds is 'minmax': lb_label = 'min' ub_label = 'max' elif bounds is 'std' or bounds is None: pass else: print("No valid bounds chosen for plotting") if plot_areas: cax = ax[axis_counter] if bounds is 'std': cax.fill_between(t, stats_df['F', measure][t_min:t_max] - stats_df['F', 'std'][t_min:t_max], stats_df['F', measure][t_min:t_max] + stats_df['F', 'std'][t_min:t_max], color='darkgreen', alpha=range_alpha) cax.fill_between(t, stats_df['P', measure][t_min:t_max] - stats_df['P', 'std'][t_min:t_max], stats_df['P', measure][t_min:t_max] + stats_df['P', 'std'][t_min:t_max], color='lawngreen', alpha=range_alpha) cax.fill_between(t, stats_df['S', measure][t_min:t_max] - stats_df['S', 'std'][t_min:t_max], stats_df['S', measure][t_min:t_max] + stats_df['S', 'std'][t_min:t_max], color='m', alpha=range_alpha) elif bounds in ['percentiles', 'minmax']: cax.fill_between(t, stats_df['F', lb_label][t_min:t_max], stats_df['F', ub_label][t_min:t_max], color='darkgreen', alpha=range_alpha) cax.fill_between(t, stats_df['P', lb_label][t_min:t_max], stats_df['P', ub_label][t_min:t_max], color='lawngreen', alpha=range_alpha) cax.fill_between(t, stats_df['S', lb_label][t_min:t_max], stats_df['S', ub_label][t_min:t_max], color='m', alpha=range_alpha) cax.plot(t, stats_df['F', measure][t_min:t_max], color='darkgreen', linewidth=2., label='Forest F') cax.plot(t, stats_df['P', measure][t_min:t_max], color='lawngreen', linewidth=2., label='Pasture P') cax.plot(t, stats_df['S', measure][t_min:t_max], color='m', linewidth=2., label='Sec. vegetation S') cax.set_ylabel(r'$F, P, S$ [ha]', fontsize=axis_label_fontsize) if stats_df['F', measure].max() < 1: cax.set_ylim([-0.1, 1.1]) cax.set_xlim([t_min, t_max]) cax.legend(loc='right') cax.annotate(plot_labels[axis_counter], xy=annotation_pos, xycoords='axes fraction', fontsize=axis_label_fontsize, xytext=annotation_offset, textcoords='offset points', horizontalalignment='left', verticalalignment='top') axis_counter += 1 if plot_qk: cax = ax[axis_counter] cax.plot(t, stats_df['q', measure][t_min:t_max], color='saddlebrown', linewidth=2., label='pasture productivity q') if bounds is 'std': cax.fill_between(t, stats_df['q', measure][t_min:t_max] - stats_df['q', 'std'][t_min:t_max], stats_df['q', measure][t_min:t_max] + stats_df['q', 'std'][t_min:t_max], color='saddlebrown', alpha=range_alpha) elif bounds in ['percentiles', 'minmax']: cax.fill_between(t, stats_df['q', lb_label][t_min:t_max], stats_df['q', ub_label][t_min:t_max], color='saddlebrown', alpha=range_alpha) if secveg_dynamics: cax.plot(t, stats_df['v', measure][t_min:t_max], color='m', linewidth=2., label='soil quality on S v') if bounds is 'std': cax.fill_between(t, stats_df['v', measure][t_min:t_max] - stats_df['v', 'std'][t_min:t_max], stats_df['v', measure][t_min:t_max] + stats_df['v', 'std'][t_min:t_max], color='m', alpha=range_alpha) elif bounds in ['percentiles', 'minmax']: cax.fill_between(t, stats_df['v', lb_label][t_min:t_max], stats_df['v', ub_label][t_min:t_max], color='m', alpha=range_alpha) cax.set_ylabel(r'$q$, $v$ [a.u.]', fontsize=axis_label_fontsize, color='k') else: cax.set_ylabel(r'$q$ [a.u.]', fontsize=axis_label_fontsize, color='saddlebrown') if not secveg_dynamics: for tl in cax.get_yticklabels(): tl.set_color('saddlebrown') # plot k if max(stats_df['k', measure][t_min:t_max]) > 500000: rescale_k = 1000000 rescale_k_label = "million " elif max(stats_df['k', measure][t_min:t_max]) > 1000: rescale_k = 1000 rescale_k_label = "1000 " else: rescale_k = 1 rescale_k_label = "" cax2 = cax.twinx() cax2.set_xlim([t_min, t_max]) cax2.plot(t, stats_df['k', measure][t_min:t_max]/rescale_k, 'b', linewidth=2., label=r'savings $k$') # , marker='o', fillstyle = 'none') label_str = 'savings\n[{}BRL]'.format(rescale_k_label) cax2.set_ylabel(label_str, color='b', fontsize=axis_label_fontsize) if bounds is 'std': cax2.fill_between(t, (stats_df['k', measure][t_min:t_max] - stats_df['k', 'std'][t_min:t_max])/rescale_k, (stats_df['k', measure][t_min:t_max] + stats_df['k', 'std'][t_min:t_max])/rescale_k, color='b', alpha=range_alpha) elif bounds in ['percentiles', 'minmax']: cax2.fill_between(t, stats_df['k', lb_label][t_min:t_max]/rescale_k, stats_df['k', ub_label][t_min:t_max]/rescale_k, color='b', alpha=range_alpha) for tick_label in cax2.get_yticklabels(): tick_label.set_color('b') if secveg_dynamics: cax.legend(loc='lower right') # loc='upper right') cax.annotate(plot_labels[axis_counter], xy=annotation_pos, xycoords='axes fraction', fontsize=axis_label_fontsize, xytext=annotation_offset, textcoords='offset points', horizontalalignment='left', verticalalignment='top') axis_counter += 1 if plot_strategy: cax = ax[axis_counter] if ensemble_stats: if bounds is 'std': cax.fill_between(t, stats_df["strategy", measure][t_min:t_max] - stats_df["strategy", "std"][t_min:t_max], stats_df["strategy", measure][t_min:t_max] + stats_df["strategy", "std"][t_min:t_max], color='k', alpha=range_alpha) elif bounds in ['percentiles', 'minmax']: cax.fill_between(t, stats_df["strategy", lb_label][t_min:t_max], stats_df["strategy", ub_label][t_min:t_max], color='k', alpha=range_alpha) cax.plot(t, stats_df["strategy", measure][t_min:t_max], linewidth=2., color='k') else: cax.plot(t, stats_df["strategy", "mean"][t_min:t_max], linewidth=2., color='k') cax.set_ylim([0., 1.]) cax.set_ylabel(r'intensification', fontsize=axis_label_fontsize) if plot_active_ranches: cax.plot(t, stats_df["active_ranches", "mean"][t_min:t_max], linewidth=2., color='b') cax.annotate(plot_labels[axis_counter], xy=annotation_pos, xycoords='axes fraction', fontsize=axis_label_fontsize, xytext=annotation_offset, textcoords='offset points', horizontalalignment='left', verticalalignment='top') axis_counter += 1 if plot_price: cax = ax[axis_counter] if ensemble_stats: if bounds is 'std': cax.fill_between(t, (stats_df["cattle_price", measure][t_min:t_max] - stats_df["cattle_price", "std"][t_min:t_max])/1000, (stats_df["cattle_price", measure][t_min:t_max] + stats_df["cattle_price", "std"][t_min:t_max])/1000, color='k', alpha=range_alpha) elif bounds in ['percentiles', 'minmax']: cax.fill_between(t, stats_df["cattle_price", lb_label][t_min:t_max]/1000, stats_df["cattle_price", ub_label][t_min:t_max]/1000, color='k', alpha=range_alpha) cax.plot(t, stats_df["cattle_price", measure][t_min:t_max]/1000, linewidth=2., color='k') else: cax.plot(t, stats_df["cattle_price", "mean"][t_min:t_max]/1000, linewidth=2., color='k') cax.set_ylabel("cattle price\n[1000 BRL]", fontsize=axis_label_fontsize) cax.set_ylim(bottom=0.9, top=3.7) cax2 = cax.twinx() if stats_df["cattle_quantity", measure][t_min:t_max].max() > 500000: rescale_cattle_quantity = 1000000 print_rescale_cattle_quantity = "million" elif stats_df["cattle_quantity", measure][t_min:t_max].max() > 1000: rescale_cattle_quantity = 1000 print_rescale_cattle_quantity = "1000" else: rescale_cattle_quantity = 1 print_rescale_cattle_quantity = "" if ensemble_stats: if bounds is 'std': cax2.fill_between(t, (stats_df["cattle_quantity", measure][t_min:t_max] - stats_df["cattle_quantity", "std"][t_min:t_max]) / rescale_cattle_quantity, (stats_df["cattle_quantity", measure][t_min:t_max] + stats_df["cattle_quantity", "std"][t_min:t_max]) / rescale_cattle_quantity, color='r', alpha=range_alpha) elif bounds in ['percentiles', 'minmax']: cax2.fill_between(t, stats_df["cattle_quantity", lb_label][t_min:t_max]/rescale_cattle_quantity, stats_df["cattle_quantity", ub_label][t_min:t_max]/rescale_cattle_quantity, color='r', alpha=range_alpha) cax2.plot(t, stats_df["cattle_quantity", measure][t_min:t_max]/rescale_cattle_quantity, linewidth=2., color='r') else: cax2.plot(t, stats_df["cattle_quantity", "mean"][t_min:t_max], linewidth=2., color='r') if rescale_cattle_quantity == 1: cax2.set_ylabel('cattle production\n[heads]', fontsize=axis_label_fontsize, color='r') else: cax2.set_ylabel('cattle production\n[{} heads]'.format(print_rescale_cattle_quantity), fontsize=axis_label_fontsize, color='r') for tl in cax2.get_yticklabels(): tl.set_color('r') cax.annotate(plot_labels[axis_counter], xy=annotation_pos, xycoords='axes fraction', fontsize=axis_label_fontsize, xytext=annotation_offset, textcoords='offset points', horizontalalignment='left', verticalalignment='top') axis_counter += 1 if plot_controls: cax = ax[axis_counter] cax.plot(t, stats_df['d', measure][t_min:t_max], label=r'$\left\langle d \right\rangle$', color='b') cax.plot(t, stats_df['a', measure][t_min:t_max], label=r'$\left\langle a \right\rangle$', color='r') cax.plot(t, stats_df['r', measure][t_min:t_max], label=r'$\left\langle r \right\rangle$', color='g') # ax4.plot(t, plot_l, label=r'$\left\langle l \right\rangle$', # color='m') cax.plot(t, stats_df['m', measure][t_min:t_max], label=r'$\left\langle m \right\rangle$', color='c') cax.set_xlim([t_min, t_max]) cax.legend(loc='upper right') cax.annotate(plot_labels[axis_counter], xy=annotation_pos, xycoords='axes fraction', fontsize=axis_label_fontsize, xytext=annotation_offset, textcoords='offset points', horizontalalignment='left', verticalalignment='top') axis_counter += 1 cax.set_xlim([t_min, t_max]) cax.set_xlabel(r'time [years]', fontsize=axis_label_fontsize) plt.tight_layout() if type(path) is not list: path = [path] for p in path: fig.savefig(p, dpi=dpi) fig.clf() plt.close(fig) return 0
def plot_data(data, name='', date=[0, 0], smas=var.default_smas, emas=var.default_emas, entry_points=None, exit_points=None, market_name='', to_file=False, show_smas=False, show_emas=False, show_bbands=False): ''' Plots selected data. entry_points is a tuple of lists: (entry_points_x,entry_points_y) ''' #plt.clf() # For when it's called outside backtest. if date != [0, 0]: if len(data) != date[1] - date[0]: data = data[date[0]:date[1]] f, (ax1, ax2, ax3) = plt.subplots(3, sharex=True, figsize=(9, 4), gridspec_kw={'height_ratios': [3, 1, 1]}) ax1.grid(True) ax2.grid(True) ax3.grid(True) # var date is causing conflicts. using name date. if date[1] == 0: end_date = len(data) else: end_date = date[1] x = range(date[0], end_date) ax1.plot(x, data.Last, color='black', linewidth=1, alpha=0.65) if show_bbands: bb_upper, bb_lower, bb_sma = bollinger_bands(data.Last, 10, 2) #ax1.plot(x, bb_upper, color='red', linestyle='none', linewidth=1) #ax1.plot(x, bb_lower, color='green', linestyle='none', linewidth=1) ax1.fill_between(x, bb_sma, bb_upper, color='green', alpha=0.3) ax1.fill_between(x, bb_lower, bb_sma, color='red', alpha=0.3) if show_smas: for sma in smas: ax1.plot(x, data.Last.rolling(sma).mean()) if show_emas: for ema in emas: ax1.plot(x, data.Last.ewm(ema).mean()) if entry_points: ax1.plot(entry_points[0], entry_points[1], marker='o', linestyle='None', color='green', alpha=0.75) if exit_points: ax1.plot(exit_points[0], exit_points[1], marker='o', linestyle='None', color='red', alpha=0.75) ax2.bar(x, data.BaseVolume.iloc[:], 1, color='black', alpha=0.55) try: ax3.plot(x, data.OpenSell.iloc[:]) except Exception as e: ax3.plot(x, data.High.iloc[:]) plt.xlim(date[0], end_date) plt.tight_layout() f.subplots_adjust(hspace=0) if to_file: if not name: name = 'fig_test' + str(time()) f.savefig(var.fig_dir + name + '.pdf', bbox_inches='tight') plt.close(f) #plt.show() return True
def make_model_evaluation(df_nonnan, model_path, ls_pred_dt, cfg_tds, cfg_op): X_test_ls = [] y_test_ls = [] cmap_pred_dt = plt.cm.get_cmap('viridis_r') ## Import dictionary with selected models: train_path_name = os.path.join( model_path, "model_dict_t0diff_maxdepth6_selfeat_gain.pkl") with open(train_path_name, "rb") as file: dict_sel_model = pickle.load(file) plt.close() fig = plt.figure(num=1, figsize=(7, 6)) ## Loop over lead times: for i, pred_dt in enumerate(ls_pred_dt): if i == 0: xgb_model_ls = [] pred_model_ls = [] Rank_obs_ls = [] top_features_ls = [] df_param_ls_diff = [] df_param_ls_rank = [] df_param_ls_rank_PM = [] df_param_ls_rank_pers = [] Rank_pred_XGB_ls = [] Rank_pred_XGB_PM_ls = [] if len(X_test_ls) == len(ls_pred_dt) and len(y_test_ls) == len( ls_pred_dt): X_test = X_test_ls[i] y_test = y_test_ls[i] else: if i == 0: X_test_ls = [] y_test_ls = [] X_train, X_test, y_train, y_test = ipt.get_model_input( df_nonnan, del_TRTeqZero_tpred=True, split_Xy_traintest=True, X_normalise=False, pred_dt=pred_dt, check_for_nans=False, verbose=True) del (X_train, y_train) X_test_ls.append(X_test) y_test_ls.append(y_test) ## Load XGB model fitted to all features: with open( os.path.join(model_path, "model_%i_t0diff_maxdepth6.pkl" % pred_dt), "rb") as file: xgb_model_feat = pickle.load(file) xgb_model_ls.append(xgb_model_feat) top_features = pd.DataFrame.from_dict( xgb_model_feat.get_booster().get_score(importance_type='gain'), orient="index", columns=["F_score"]).sort_values(by=['F_score'], ascending=False) top_features_ls.append(top_features) ## Get specific predictive model for this leadtime: pred_model = dict_sel_model["pred_mod_%i" % pred_dt] pred_model_ls.append(pred_model) ## Check that features agree: features_pred_model = pred_model.get_booster().feature_names n_features = len(features_pred_model) if set(features_pred_model) != set(top_features.index[:n_features]): raise ValueError( "Features of predictive model and top features of model fitted with all features do not agree" ) ## Make prediction of TRT Rank differences: TRT_diff_pred = pred_model.predict(X_test[features_pred_model]) ## Get set of different TRT Rank predictions: Rank_obs, Rank_pred_XGB, Rank_pred_XGB_PM, Rank_pred_pers, Rank_pred_pers_PM, \ Rank_pred_diff, Diff_pred_XGB = get_obs_fcst_TRT_Rank(X_test["TRT_Rank|0"], TRT_diff_pred, y_test, X_test["TRT_Rank|-5"]) Rank_obs_ls.append(Rank_obs) Rank_pred_XGB_ls.append(Rank_pred_XGB) Rank_pred_XGB_PM_ls.append(Rank_pred_XGB_PM) ## Plot scatterplots obs vs. predicted: plot_pred_vs_obs_core(y_test, Diff_pred_XGB.values, pred_dt, "_XGB%i" % n_features, cfg_tds, outtype="TRT_Rank_diff") plot_pred_vs_obs_core(Rank_obs, Rank_pred_XGB.values, pred_dt, "_XGB%i" % n_features, cfg_tds, outtype="TRT_Rank") plot_pred_vs_obs_core(Rank_obs, Rank_pred_XGB_PM.values, pred_dt, "_XGB%i-ProbMatch" % n_features, cfg_tds, outtype="TRT_Rank") plot_pred_vs_obs_core(Rank_obs, Rank_pred_pers.values, pred_dt, "_Pers", cfg_tds, outtype="TRT_Rank") plot_pred_vs_obs_core(Rank_obs, Rank_pred_pers_PM.values, pred_dt, "_Pers-ProbMatch", cfg_tds, outtype="TRT_Rank") plot_pred_vs_obs_core(Rank_obs, Rank_pred_diff.values, pred_dt, "_ConstDiff", cfg_tds, outtype="TRT_Rank") ## Calculate different term elements for R^2 / Brier Score calculation: df_param_ls_diff.append( get_R2_param(y_test.values, Diff_pred_XGB.values)) df_param_ls_rank.append( get_R2_param(Rank_obs.values, Rank_pred_XGB.values)) df_param_ls_rank_PM.append( get_R2_param(Rank_obs.values, Rank_pred_XGB_PM.values)) df_param_ls_rank_pers.append( get_R2_param(Rank_obs.values, Rank_pred_pers.values)) ## Calculate statistics for Taylor Diagram: stat_pred_XGB = sm.taylor_statistics(predicted=Rank_pred_XGB.values, reference=Rank_obs.values) stat_pred_XGB_PM = sm.taylor_statistics( predicted=Rank_pred_XGB_PM.values, reference=Rank_obs.values) stat_pred_pred_pers = sm.taylor_statistics( predicted=Rank_pred_pers.values, reference=Rank_obs.values) stat_pred_pred_diff = sm.taylor_statistics( predicted=Rank_pred_diff.values, reference=Rank_obs.values) stat_pred_pred_pers_PM = sm.taylor_statistics( predicted=Rank_pred_pers_PM.values, reference=Rank_obs.values) sdev = np.array([ stat_pred_XGB['sdev'][0], stat_pred_XGB['sdev'][1], stat_pred_XGB_PM['sdev'][1], stat_pred_pred_pers['sdev'][1] ]) crmsd = np.array([ stat_pred_XGB['crmsd'][0], stat_pred_XGB['crmsd'][1], stat_pred_XGB_PM['crmsd'][1], stat_pred_pred_pers['crmsd'][1] ]) ccoef = np.array([ stat_pred_XGB['ccoef'][0], stat_pred_XGB['ccoef'][1], stat_pred_XGB_PM['ccoef'][1], stat_pred_pred_pers['ccoef'][1] ]) #sdev = np.array([stat_pred_XGB['sdev'][0], stat_pred_XGB['sdev'][1], stat_pred_XGB_PM['sdev'][1], stat_pred_pred_pers['sdev'][1], stat_pred_pred_diff['sdev'][1]]) #crmsd = np.array([stat_pred_XGB['crmsd'][0], stat_pred_XGB['crmsd'][1], stat_pred_XGB_PM['crmsd'][1], stat_pred_pred_pers['crmsd'][1], stat_pred_pred_diff['crmsd'][1]]) #ccoef = np.array([stat_pred_XGB['ccoef'][0], stat_pred_XGB['ccoef'][1], stat_pred_XGB_PM['ccoef'][1], stat_pred_pred_pers['ccoef'][1], stat_pred_pred_diff['ccoef'][1]]) ## Plot Taylor Diagram: col_point = cmap_pred_dt(float(i) / len(ls_pred_dt)) col_point = (col_point[0], col_point[1], col_point[2], 0.8) plot_markerLabel = ["Obs", "+%imin" % pred_dt, "", ""] plot_markerLabelColor = "black" if i == 0: plot_markerLegend = 'on' plot_overlay = 'off' else: plot_markerLegend = "on" plot_overlay = 'on' #plot_markerLabelColor = None if i == len(ls_pred_dt) - 1: plot_markerLabelColor = None plot_markerLabel = ["Obs", "XGB", "XGB (PM)", "Persistance"] sm.taylor_diagram( sdev / sdev[0], crmsd, ccoef, styleOBS='-', colOBS='darkred', markerobs='o', titleOBS='Obs', markerLabel=plot_markerLabel, markerLabelColor=plot_markerLabelColor, alpha=0.1, markerColor=col_point, markerLegend=plot_markerLegend, axismax=1.2, markerSize=5, colRMS='grey', styleRMS='--', widthRMS=0.8, rincRMS=0.25, tickRMS=np.arange(0.25, 1.5, 0.25), #titleRMSangle = 110, colSTD='grey', styleSTD='-.', widthSTD=0.8, colCOR='grey', styleCOR=':', widthCOR=0.8, overlay=plot_overlay) ## Save Taylor Diagram: get_time_delta_colorbar(fig, ls_pred_dt, cmap_pred_dt, [0.7, 0.5, 0.05, 0.3]) plt.savefig( os.path.join(cfg_tds["fig_output_path"], "Taylor_Diagram_cmap.pdf")) plt.close() ## Plot histogram showing the effect of probability matching: print( "Save dataframe with observed, predicted, and predicted & PM TRT Ranks" ) Rank_obs_df = pd.concat(Rank_obs_ls, axis=1, sort=True) Rank_obs_df.columns = [ "TRT_Rank_obs|%i" % pred_dt for pred_dt in ls_pred_dt ] Rank_pred_XGB_df = pd.concat(Rank_pred_XGB_ls, axis=1, sort=True) Rank_pred_XGB_df.columns = [ "TRT_Rank_pred|%i" % pred_dt for pred_dt in ls_pred_dt ] Rank_pred_XGB_PM_df = pd.concat(Rank_pred_XGB_PM_ls, axis=1, sort=True) Rank_pred_XGB_PM_df.columns = [ "TRT_Rank_pred_PM|%i" % pred_dt for pred_dt in ls_pred_dt ] #plot_hist_probmatch(Rank_pred_XGB_df, Rank_pred_XGB_PM_df) Rank_obs_pred_df = pd.concat( [Rank_obs_df, Rank_pred_XGB_df, Rank_pred_XGB_PM_df], axis=1, sort=True) ## Get dataframe with observed, predicted, and predicted & PM TRT Ranks for operational PM: op_path_name = os.path.join(cfg_op["XGB_model_path"], "TRT_Rank_obs_pred.pkl") with open(op_path_name, "wb") as file: pickle.dump(Rank_obs_pred_df, file, protocol=2) print(" saved dict to 'XGB_model_path' location:\n %s" % op_path_name) prt_txt = """ --------------------------------------------------------------------------------- The file 'TRT_Rank_obs_pred.pkl' in the directory '%s' is now used for the operational probability matching procedure, be aware of that! ---------------------------------------------------------------------------------\n""" % ( cfg_op["XGB_model_path"]) print(prt_txt) ## Plot skill scores as function of lead-time: df_R2_param_rank = pd.concat(df_param_ls_rank, axis=0).set_index(np.array(ls_pred_dt)) df_R2_param_rank_PM = pd.concat(df_param_ls_rank_PM, axis=0).set_index(np.array(ls_pred_dt)) df_R2_param_diff = pd.concat(df_param_ls_diff, axis=0).set_index(np.array(ls_pred_dt)) df_R2_param_rank_pers = pd.concat(df_param_ls_rank_pers, axis=0).set_index(np.array(ls_pred_dt)) plot_stats(df_R2_param_rank, "TRT_Rank", cfg_tds) plot_stats(df_R2_param_diff, "TRT_Rank_diff", cfg_tds) plot_stats_nice(df_R2_param_rank, "TRT_Rank", cfg_tds) plot_stats_nice(df_R2_param_diff, "TRT_Rank_diff", cfg_tds) plot_stats_nice(df_R2_param_rank_pers, "TRT_Rank_pers", cfg_tds) plot_stats_nice(df_R2_param_rank_PM, "TRT_Rank_PM", cfg_tds) ## Print IDs of long TRT cells in testing dataset: print( "\nThese are the IDs of long TRT cells (>25 time steps) in the testing dataset:" ) TRT_ID = X_test_ls[-1].index TRT_ID = [TRT_ID_i[13:] for TRT_ID_i in TRT_ID.values] TRT_ID_count = Counter(TRT_ID) TRT_ID_count_sort = [ (k, TRT_ID_count[k]) for k in sorted(TRT_ID_count, key=TRT_ID_count.get, reverse=True) ] TRT_ID_count_sort_pd = pd.DataFrame(np.array(TRT_ID_count_sort), columns=["TRT_ID", "Count"]) TRT_ID_count_sort_pd["Count"] = TRT_ID_count_sort_pd["Count"].astype( np.uint16, inplace=True) TRT_ID_long = TRT_ID_count_sort_pd.loc[TRT_ID_count_sort_pd["Count"] > 25] print(TRT_ID_long) TRT_ID_casestudy = [ "2018080721250094", "2018080721300099", "2018080711400069", "2018080710200036" ] print(" Making analysis for TRT IDs (hardcoded!): %s" % TRT_ID_casestudy) TRT_ID_long_sel = TRT_ID_long.loc[TRT_ID_long['TRT_ID'].isin( TRT_ID_casestudy)] df_feature_ts_plot = pd.DataFrame.from_dict({ "Radar": ["CZC_lt57dBZ|-45|SUM", "CZC_lt57dBZ|-45|SUM", "CZC_lt57dBZ|-45|SUM"], "Satellite": [ "IR_097_stat|-20|PERC05", "IR_097_stat|-15|PERC01", "IR_097_stat|-20|MIN" ], "COSMO": [ "CAPE_MU_stat|-10|PERC50", "CAPE_MU_stat|-5|PERC75", "CAPE_ML_stat|0|SUM" ], "Lightning": [ "THX_densIC_stat|-30|SUM", "THX_curr_pos_stat|-40|SUM", "THX_curr_pos_stat|-30|SUM" ] }) for i_sel in range(len(TRT_ID_long_sel)): print(" Working on cell %s" % TRT_ID_long_sel.iloc[i_sel]["TRT_ID"]) plot_pred_time_series(TRT_ID_long_sel.iloc[i_sel], df_nonnan, Rank_pred_XGB_ls, ls_pred_dt, cfg_tds) plot_pred_time_series(TRT_ID_long_sel.iloc[i_sel], df_nonnan, Rank_pred_XGB_PM_ls, ls_pred_dt, cfg_tds, path_addon="PM", title_addon=" (PM)") plot_var_time_series_dt0_multiquant(TRT_ID_long_sel.iloc[i_sel], df_nonnan, cfg_tds) for i_pred_dt, pred_dt in enumerate([10, 20, 30]): fig = plt.figure(figsize=[10, 6]) ax_rad = fig.add_subplot(2, 2, 1) ax_sat = fig.add_subplot(2, 2, 2) ax_cos = fig.add_subplot(2, 2, 3) ax_thx = fig.add_subplot(2, 2, 4) ax_ls = [ax_rad, ax_sat, ax_cos, ax_thx] #fig, axes = plt.subplots(2,2) #fig.set_size_inches(8,6) for i_source, source in enumerate( ["Radar", "Satellite", "COSMO", "Lightning"]): ls_feat_param = df_feature_ts_plot[source].iloc[ i_pred_dt].split("|") past_dt = np.arange(-45, 0, 5) if int(ls_feat_param[1]) != 0 else [0] ax_ls[i_source] = plot_var_time_series( TRT_ID_long_sel.iloc[i_sel], df_nonnan, ls_feat_param[0], ls_feat_param[2], past_dt=past_dt, dt_highlight=int(ls_feat_param[1]), ax=ax_ls[i_source]) plt.tight_layout() plt.savefig( os.path.join( cfg_tds["fig_output_path"], "Feat_series_%i_%s.pdf" % (pred_dt, TRT_ID_long_sel.iloc[i_sel]["TRT_ID"]))) plt.close()
ax2.errorbar(xlocs, binned_correlation_times, yerr=2 * errs, marker='o', markersize=5) #ax6.plot(xlocs,binned_correlation_times,marker='o',markersize=4) ax1.set_xlabel(r'Cell speed ($\mu$m/min)') ax1.set_ylabel('Persistence time (min)') ax4.set_ylabel('Persistence time (min)') ax1.set_title('Zebrafish T cells', fontsize=10) ax3.set_xlabel(r'Cell speed ($\mu$m/min)') ax4.set_xlabel(r'Cell speed ($\mu$m/min)') ax5.set_xlabel(r'Cell speed ($\mu$m/min)') ax6.set_xlabel(r'Cell speed ($\mu$m/min)') ax2.set_xlabel(r'Cell speed ($\mu$m/min)') ax3.set_title('UPT', fontsize=10) ax4.set_title('UPT with noise', fontsize=10) ax5.set_title('S and P uncorrelated', fontsize=10) ax6.set_title('S and P uncorrelated with noise', fontsize=10) ax2.set_title('SPC with noise', fontsize=10) ax1.text(-.1, 1.1, 'A', fontsize=12, transform=ax1.transAxes) ax2.text(-.1, 1.1, 'B', fontsize=12, transform=ax2.transAxes) ax3.text(-.1, 1.1, 'C', fontsize=12, transform=ax3.transAxes) ax4.text(-.1, 1.1, 'D', fontsize=12, transform=ax4.transAxes) ax5.text(-.1, 1.1, 'E', fontsize=12, transform=ax5.transAxes) ax6.text(-.1, 1.1, 'F', fontsize=12, transform=ax6.transAxes) pt.tight_layout() pt.savefig( '/Users/ejerison/Dropbox/imaging_data/figures/empirical_sims_v2.pdf')
def flat_corr_matrix(df, pdf=None, tight=False, labels=None, label_size=None, size=12, n_labels=3, fontsize='auto', draw_cbar=False, tick_label_rotation=45, formatter='%.2e', label_rotation=45, cmap='PiYG'): """ Draws a flat correlation matrix of df Args: df: pdf: tight: col_numbers: labels: label_size: size: n_labels: fontsize: draw_cbar: rotation: formatter: Returns: """ assert isinstance( df, pd.DataFrame), 'Argument of wrong type! Needs pd.DataFrame' n_vars = np.shape(df)[1] fontsize = np.interp(n_vars, (0, 10), (22, 10)) if fontsize is 'auto' else fontsize if labels is None: labels = df.columns else: assert len(labels) == len( df.columns ), "Numbers of labels not matching the numbers of coulums in the df" im = None fig, axes = plt.subplots(nrows=n_vars, ncols=n_vars, figsize=(size, size)) # Plotting the matrix, iterate over the columns in 2D for i, row in zip(range(n_vars), axes): for j, ax in zip(range(n_vars), row): if i is j - 1000: plt.sca(ax) ax.hist(df.iloc[:, i].values, label='data', color='gray') ax.set_yticklabels([]) else: im = flat_correlation(df.iloc[:, j], df.iloc[:, i], ax=ax, draw_labels=False, get_im=True, cmap=cmap) ax.xaxis.set_major_locator(plt.NullLocator()) ax.yaxis.set_major_locator(plt.NullLocator()) if tight: plt.tight_layout() # Common outer label for i, row in zip(range(n_vars), axes): for j, ax in zip(range(n_vars), row): if i == n_vars - 1: if label_size is not None: set_flat_labels(ax, df.iloc[:, j], axis=1, n_labels=n_labels, labelsize=label_size, rotation=90 if tick_label_rotation is 0 else tick_label_rotation, formatter=formatter) ax.set_xlabel(labels[j], fontsize=fontsize, rotation=label_rotation, ha='right', va='top') if j == 0: if label_size is not None: set_flat_labels(ax, df.iloc[:, i], axis=0, n_labels=n_labels, labelsize=label_size, rotation=tick_label_rotation, formatter=formatter) ax.set_ylabel(labels[i], fontsize=fontsize, rotation=label_rotation, ha='right', va='bottom') if pdf is None: # plt.show() pass else: pdf.savefig() plt.close() if draw_cbar: cbar_ax = fig.add_axes([0.92, 0.15, 0.02, 0.7]) cbar = plt.colorbar( im, cax=cbar_ax, ) cbar.ax.set_ylabel('$\sigma$', rotation=0, fontsize=fontsize * 1.2, va='center') cbar.ax.tick_params(labelsize=fontsize)
def plot_intrarater_stats(dbcon, savedir: str, clsgroup: str): """""" _maybe_mkdir(savedir) _maybe_mkdir(opj(savedir, 'csv')) _maybe_mkdir(opj(savedir, 'plots')) # read intrarater stats evalsets = ['B-control', 'E'] stats = read_sql_query(f""" SELECT "participant", "second_evalset" AS "evalset" , "detection_and_classification", "classification" , "n_anchors_second_evalset" AS "n_anchors" , "n_clicks_second_evalset" AS "n_clicks" FROM "intra-rater_{clsgroup}ClassGroup" WHERE "participant" IN ({ir._get_sqlite_usrstr_for_who('All')}) AND "first_evalset" = "U-control" AND "second_evalset" IN ({ir._get_sqlitestr_for_list(evalsets)}) ;""", dbcon) stats.loc[:, 'psegmented'] = stats.loc[ :, 'n_clicks'] / stats.loc[:, 'n_anchors'] # to save raw values for calculating p-values later overalldf = [] # reorder evalsets tmp = [] for evalset in ir.EVALSET_NAMES: tmp.append(stats.loc[stats.loc[:, 'evalset'] == evalset, :]) stats = concat(tmp, axis=0) # organize canvas and plot nperrow = 3 nrows = 1 fig, ax = plt.subplots(nrows, nperrow, figsize=(5 * nperrow, 5.5 * nrows)) scprops = {'alpha': 0.7, 's': 7 ** 2, 'edgecolor': 'k'} axno = -1 metrics = ['psegmented', 'detection_and_classification', 'classification'] mdict = { 'psegmented': 'N. segmentations / N. anchors', 'detection_and_classification': "Kappa vs U-control (det. & classif.)", 'classification': "Kappa vs U-control (classif.)", } for axis in ax.ravel(): axno += 1 metric = metrics[axno] dfslice = stats.copy() dfslice.index = dfslice.loc[:, 'participant'] dfslice.loc[:, 'who'] = 'NPs' for who in ['JPs', 'SPs']: for p in dfslice.index: if p in ir.who[who]: dfslice.loc[p, 'who'] = who dfslice.loc[:, 'swho'] = dfslice.loc[:, 'who'].copy() dfslice.loc[dfslice.loc[:, 'swho'] == 'SPs', 'swho'] = 'Ps' dfslice.loc[dfslice.loc[:, 'swho'] == 'JPs', 'swho'] = 'Ps' dfslice = dfslice.loc[:, ['evalset', metric, 'who', 'swho']] overalldf.append(dfslice) # annotate agreement ranges if axno > 0: _annotate_krippendorph_ranges( axis=axis, minx=0, maxx=2, shades=False) # main boxplots bppr = {'alpha': 0.5} sns.boxplot( ax=axis, data=dfslice, x='evalset', y=metric, hue='swho', palette=[ir.PARTICIPANT_STYLES[who]['c'] for who in ['Ps', 'NPs']], boxprops=bppr, whiskerprops=bppr, capprops=bppr, medianprops=bppr, showfliers=False, notch=False, bootstrap=5000) # scatter each participant group for who in ['NPs', 'JPs', 'SPs']: pstyle = ir.PARTICIPANT_STYLES[who] scprops.update({k: pstyle[k] for k in ['c', 'marker']}) plotme = dfslice.loc[dfslice.loc[:, 'who'] == who, :].copy() offset = -0.2 if who in ['JPs', 'SPs'] else 0.2 plotme.loc[:, 'x'] = plotme.loc[:, 'evalset'].apply( lambda x: evalsets.index(x) + offset) plotme = np.array(plotme.loc[:, ['x', metric]]) # add jitter plotme[:, 0] += 0.05 * np.random.randn(plotme.shape[0]) # now scatter axis.scatter( plotme[:, 0], plotme[:, 1], label=f'{who}', **scprops) axis.set_ylim(0., 1.) axis.set_title(mdict[metric], fontsize=14, fontweight='bold') axis.set_ylabel(metric.capitalize(), fontsize=11) axis.legend() plt.tight_layout(pad=0.3, w_pad=0.5, h_pad=0.3) savename = f'intra-rater_comparison' plt.savefig(opj(savedir, 'plots', savename + '.svg')) plt.close() # save raw numbers overalldf = concat(overalldf, axis=0) overalldf.to_csv(opj(savedir, 'csv', savename + '.csv'))
plt.plot(Utils.movingAverage(average), label=str(2 * numOptionsToUse) + ' opt.', color=Utils.colors[color_idx]) else: plt.plot(Utils.movingAverage(average), label=str(numOptionsToUse) + ' opt.', color=Utils.colors[color_idx]) plt.fill_between(range(len(Utils.movingAverage(average))), Utils.movingAverage(minConfInt), Utils.movingAverage(maxConfInt), alpha=0.5, color=Utils.colors[color_idx]) plt.legend(loc='upper left', prop={'size': 10}, bbox_to_anchor=(1, 1)) plt.tight_layout(pad=7) plt.show() elif taskToPerform == 7: #Solve for a given goal w/ primitive actions (q-learning) #following discovered AND loaded options This one is for comparison. numOptionsLoadedToConsider = 4 numOptionsDiscoveredToConsider = 128 returnsEvalPrimitive1, returnsEvalDiscovered, totalOptionsToUseDiscovered = qLearningWithOptions( env=env, alpha=0.1, gamma=0.9, options_eps=0.0, epsilon=1.0, nSeeds=num_seeds, maxLengthEp=max_length_episode,
def eval(**kwargs): # Roll out the parameters batch_size = kwargs["batch_size"] generator = kwargs["generator"] model_name = kwargs["model_name"] image_data_format = kwargs["image_data_format"] img_dim = kwargs["img_dim"] cont_dim = (kwargs["cont_dim"],) cat_dim = (kwargs["cat_dim"],) noise_dim = (kwargs["noise_dim"],) bn_mode = kwargs["bn_mode"] noise_scale = kwargs["noise_scale"] dset = kwargs["dset"] eval_epoch = kwargs["eval_epoch"] # Setup environment (logging directory etc) general_utils.setup_logging(**kwargs) # Load and rescale data if dset == "RGZ": X_real_train = data_utils.load_RGZ(img_dim, image_data_format) if dset == "mnist": X_real_train, _, _, _ = data_utils.load_mnist(image_data_format) img_dim = X_real_train.shape[-3:] # Load generator model generator_model = models.load("generator_%s" % generator, cat_dim, cont_dim, noise_dim, img_dim, bn_mode, batch_size, dset=dset) # Load colorization model generator_model.load_weights("../../models/%s/gen_weights_epoch%05d.h5" % (model_name, eval_epoch)) X_plot = [] # Vary the categorical variable for i in range(cat_dim[0]): X_noise = data_utils.sample_noise(noise_scale, batch_size, noise_dim) X_cont = data_utils.sample_noise(noise_scale, batch_size, cont_dim) X_cont = np.repeat(X_cont[:1, :], batch_size, axis=0) # fix continuous noise X_cat = np.zeros((batch_size, cat_dim[0]), dtype='float32') X_cat[:, i] = 1 # always the same categorical value X_gen = generator_model.predict([X_cat, X_cont, X_noise]) X_gen = data_utils.inverse_normalization(X_gen) if image_data_format == "channels_first": X_gen = X_gen.transpose(0,2,3,1) X_gen = [X_gen[i] for i in range(len(X_gen))] X_plot.append(np.concatenate(X_gen, axis=1)) X_plot = np.concatenate(X_plot, axis=0) plt.figure(figsize=(8,10)) if X_plot.shape[-1] == 1: plt.imshow(X_plot[:, :, 0], cmap="gray") else: plt.imshow(X_plot) plt.xticks([]) plt.yticks([]) plt.ylabel("Varying categorical factor", fontsize=28, labelpad=60) plt.annotate('', xy=(-0.05, 0), xycoords='axes fraction', xytext=(-0.05, 1), arrowprops=dict(arrowstyle="-|>", color='k', linewidth=4)) plt.tight_layout() plt.savefig(os.path.join("../../figures", model_name, "varying_categorical.png")) plt.clf() plt.close() # Vary the continuous variables X_plot = [] # First get the extent of the noise sampling x = np.ravel(data_utils.sample_noise(noise_scale, batch_size * 20000, cont_dim)) # Define interpolation points x = np.linspace(x.min(), x.max(), num=batch_size) for i in range(batch_size): X_noise = data_utils.sample_noise(noise_scale, batch_size, noise_dim) X_cont = np.concatenate([np.array([x[i], x[j]]).reshape(1, -1) for j in range(batch_size)], axis=0) X_cat = np.zeros((batch_size, cat_dim[0]), dtype='float32') X_cat[:, 1] = 1 # always the same categorical value X_gen = generator_model.predict([X_cat, X_cont, X_noise]) X_gen = data_utils.inverse_normalization(X_gen) if image_data_format == "channels_first": X_gen = X_gen.transpose(0,2,3,1) X_gen = [X_gen[i] for i in range(len(X_gen))] X_plot.append(np.concatenate(X_gen, axis=1)) X_plot = np.concatenate(X_plot, axis=0) plt.figure(figsize=(10,10)) if X_plot.shape[-1] == 1: plt.imshow(X_plot[:, :, 0], cmap="gray") else: plt.imshow(X_plot) plt.xticks([]) plt.yticks([]) plt.ylabel("Varying continuous factor 1", fontsize=28, labelpad=60) plt.annotate('', xy=(-0.05, 0), xycoords='axes fraction', xytext=(-0.05, 1), arrowprops=dict(arrowstyle="-|>", color='k', linewidth=4)) plt.xlabel("Varying continuous factor 2", fontsize=28, labelpad=60) plt.annotate('', xy=(1, -0.05), xycoords='axes fraction', xytext=(0, -0.05), arrowprops=dict(arrowstyle="-|>", color='k', linewidth=4)) plt.tight_layout() plt.savefig(os.path.join("../../figures", model_name, "varying_continuous.png")) plt.clf() plt.close()
def make_all_plots(df_plotting_container, specific_plots=[], backend='matplotlib', grid_of_plots=(2, 2), kde=False, plot_params=None, figsize=(9, 7), norm_hist=False, xlabelfontsize=12, ignorePID=False, stacked=False, alpha=0.5, decay=None, tag='default'): if plot_params is None: plot_params = get_variable_parameters_for_plotting() sps_in_container = list(df_plotting_container.keys()) print(sps_in_container) tempdf = df_plotting_container[sps_in_container[0]]['df'] tempnames = None if type(tempdf) is list: tempnames = tempdf[0].columns else: tempnames = tempdf.columns #tempnames = df_plotting_container[sps_in_container[0]]['dfs'][0].columns names = [] if ignorePID: for name in tempnames: if name.find('Is') >= 0 or name.find('BDT') >= 0 or name.find( 'KM') >= 0: 1 else: names.append(name) nplots = len(names) nplots_per_figure = grid_of_plots[0] * grid_of_plots[1] grid_count = 0 i = 0 if len(specific_plots) == 0: specific_plots = list(names) figcount = 0 sps_for_labels = [] #for icount,name in enumerate(names): for icount, name in enumerate(specific_plots): #if len(specific_plots)>0 and name not in specific_plots: if name not in names: continue if i % nplots_per_figure == 0: plt.figure(figsize=figsize) grid_count = 0 plt.subplot(grid_of_plots[0], grid_of_plots[1], grid_count + 1) plotrange = None xlabel = None bins = 100 if name in plot_params.keys(): xlabel = plot_params[name]['xlabel'] plotrange = plot_params[name]['range'] if 'bins' in list(plot_params[name].keys()): bins = plot_params[name]['bins'] if name.find('Is') >= 0 or name.find('BDT') >= 0 or name.find( 'KM') >= 0: plotrange = (0, 1) bins = 2 ######################################################################## ''' if backend=='seaborn': if plotrange is not None: for j,df in enumerate(dfs): label = None if labels is not None: label = labels[j] weight=np.ones(len(df[name])) if type(weights) == list: weight *= weights[j] sns.distplot(df[name],bins=bins,hist_kws={"range": plotrange, "weights":weight, "stacked":stacked,'alpha':alpha},kde=kde,norm_hist=norm_hist,label=label) plt.xlim(plotrange[0],plotrange[1]) else: for j,df in enumerate(dfs): label = None if labels is not None: label = labels[j] weight=np.ones(len(df[name])) if type(weights) == list: weight *= weights[j] sns.distplot(df[name],bins=bins,kde=kde,norm_hist=norm_hist,label=label,hist_kws={"weights":weight, "stacked":stacked}) if xlabel is not None: plt.xlabel(xlabel,fontsize=xlabelfontsize) else: plt.xlabel(name,fontsize=xlabelfontsize) if labels is not None: plt.legend(fontsize=8) ''' ######################################################################## if backend == 'matplotlib': #if plotrange is not None: allvals = [] allweights = [] #last_df = len(dfs) backgroundMC = { 'values': [], 'weights': [], 'colors': [], 'labels': [] } signalMC = { 'values': [], 'weights': [], 'colors': [], 'labels': [] } data = {'values': [], 'weights': [], 'colors': [], 'labels': []} totweights = 0 for sp in sps_in_container: c = df_plotting_container[sp] if c['isSignalMC'] is True: signalMC['values'] = c['df'][name] signalMC['colors'] = c['color'] signalMC['weights'] = np.ones(len( c['df'][name])) * c['weights'] signalMC['labels'] = c['label'] elif c['isData'] is True: data['values'] = c['df'][name] data['colors'] = c['color'] data['weights'] = np.ones(len( c['df'][name])) * c['weights'] data['labels'] = c['label'] else: backgroundMC['values'].append(c['df'][name]) backgroundMC['colors'].append(c['color']) backgroundMC['weights'].append( np.ones(len(c['df'][name])) * c['weights']) backgroundMC['labels'].append(c['label']) totweights += c['weights'] * np.sum(len(c['df'][name])) #print(backgroundMC) #print(backgroundMC['values']) #print(backgroundMC['weights']) #print(len(backgroundMC['values'])) #print(len(backgroundMC['weights'])) # Background #print(backgroundMC['colors']) #print(backgroundMC['labels']) plt.hist(backgroundMC['values'], bins=bins, range=plotrange, weights=backgroundMC['weights'], stacked=stacked, alpha=alpha, label=backgroundMC['labels'], color=backgroundMC['colors'], histtype='stepfilled', density=norm_hist) # Signal if len(signalMC['values']) > 0: nentries = len(signalMC['values']) #print(f"totweights: {totweights}") signalMC['weights'] = np.ones(nentries) * (totweights / nentries) * 0.15 plt.hist(signalMC['values'], bins=bins, range=plotrange, weights=signalMC['weights'], lw=2, ls='--', alpha=1.0, label=signalMC['labels'], color='b', histtype='step', density=norm_hist) # Data if len(data['values']) > 0: hist_with_errors(data['values'], bins=bins, range=plotrange, label='Data') if plotrange is not None: plt.xlim(plotrange[0], plotrange[1]) if xlabel is not None: plt.xlabel(xlabel, fontsize=xlabelfontsize) else: plt.xlabel(name, fontsize=xlabelfontsize) #plt.legend(fontsize=8,loc='upper left') plt.legend(fontsize=8, loc='best') ######################################################################## if i % nplots_per_figure == nplots_per_figure - 1 or i == nplots - 1: print("Here!") plt.tight_layout() filename = 'plots/stacked_cut_summary_files_{0}_{1}_{2}.png'.format( decay, tag, figcount) plt.savefig(filename) figcount += 1 i += 1 plt.tight_layout() grid_count += 1 filename = 'plots/stacked_cut_summary_files_{0}_{1}_{2}.png'.format( decay, tag, figcount) plt.savefig(filename)
def combine_all(self, filepath, savename, directory, skiprows, column_names, show=True): dir = directory + '/%s' % (savename.strip('.yaml')) if not os.path.exists(dir): os.makedirs(dir) if filepath.endswith('.yaml') == True: with open(filepath, 'r') as stream: data_file = yaml.load(stream) stream.close() data = data_file['data'] # parameters = data_file['parameters'] else: # parameters = open(filepath, "r").readlines()[:33] data = np.loadtxt(filepath, delimiter=',', skiprows=skiprows) length = len(data[0]) - (len(column_names) + 3) L_length = int(data[0][-1]) R_length = int(data[0][-2]) for i in range(R_length): column_names = np.append(column_names, "R_%i" % (i + 1)) for i in range(L_length): column_names = np.append(column_names, "L_%i" % (i + 1)) column_names = np.append(column_names, "Accepted") column_names = np.append(column_names, "Rayleigh_length") column_names = np.append(column_names, "Love_length") par = Get_Paramters() REAL = par.get_unkown() df = pd.DataFrame(data, columns=column_names) df_select = df[["Epi", "Depth", "Strike", "Dip", "Rake", "M0"]] fig = plt.figure(figsize=(20, 20)) ax1 = plt.subplot2grid((5, 2), (0, 0), colspan=2) # ax1.axhline(y = REAL['epi'] ,linewidth = 0.3 , linestyle =':', color = 'b') ax1.plot(df_select['Epi'], label="Epi", c='b') ax1.tick_params("y", colors='b') ax1.set_ylabel('Epicentral distance [degree]', color='b') ax2 = ax1.twinx() ax2.plot(df_select['Depth'], label="Depth", c='r') # ax2.axhline(y=REAL['depth_s'], linewidth=0.3, linestyle=':', color='r') ax2.tick_params('y', colors='r') ax2.set_ylabel('Depth [m]', color='r') plt.tight_layout() ax3 = plt.subplot2grid((5, 2), (1, 0), colspan=2) ax3.plot(df_select['Strike'], label="Strike", color="b") # ax3.axhline(y=REAL['strike'], linewidth=0.3, linestyle=':', color='b') # ax3.axhline(y=REAL['dip'], linewidth=0.3, linestyle=':', color='g') # ax3.axhline(y=REAL['rake'], linewidth=0.3, linestyle=':', color='r') ax3.plot(df_select['Dip'], label="Dip", color='g') ax3.plot(df_select['Rake'], label="Rake", color='r') ax3.set_ylabel('Moment tensor angle [degree]', color='k') plt.legend(loc='center left', bbox_to_anchor=(1, 0.5)) plt.tight_layout() axes = ax3.twinx() axes.plot(df_select['M0'], label="M0", c='m') # ax2.axhline(y=REAL['depth_s'], linewidth=0.3, linestyle=':', color='r') axes.tick_params('y', colors='m') axes.set_ylabel('M0', color='r') plt.yscale('log') plt.tight_layout() R_select = df.filter(like='R_') L_select = df.filter(like='L_') df_select_xi = df[[ "Total_misfit", "S_z", "S_r", "S_t", "P_z", "P_r", "BW_misfit", "Rtot", "Ltot" ]] ax4 = plt.subplot2grid((5, 2), (2, 0), colspan=2) ax4.plot(df_select_xi['Total_misfit'], label="Total_misfit", c='r') # ax4.plot(df_select_xi['S_z'], label = "S_z") # ax4.plot(df_select_xi['S_r'], label = "S_r") # ax4.plot(df_select_xi['S_t'], label = "S_t") # ax4.plot(df_select_xi['P_z'], label = "P_z") # ax4.plot(df_select_xi['P_r'], label = "P_r") ax4.plot(df_select_xi['BW_misfit'], label="BW_tot") ymin, ymax = ax4.get_ylim() plt.yscale('log') # plt.ylim((pow(10, 0), pow(10, 3))) plt.legend(loc='center left', bbox_to_anchor=(1, 0.5)) plt.tight_layout() ax5 = plt.subplot2grid((5, 2), (3, 0), colspan=2) # for i in R_select: # ax5.plot(R_select[i],label = i) ax5.plot(df_select_xi['Rtot'], label="Rtot") plt.yscale('log') # plt.ylim((pow(10, 0), pow(10, 4))) plt.legend(loc='center left', bbox_to_anchor=(1, 0.5)) plt.tight_layout() ax6 = plt.subplot2grid((5, 2), (4, 0), colspan=2) # for i in L_select: # ax6.plot(L_select[i],label = i) ax6.plot(df_select_xi['Ltot'], label="Ltot") plt.yscale('log') # plt.ylim((pow(10, 0), pow(10, 4))) plt.legend(loc='center left', bbox_to_anchor=(1, 0.5)) plt.tight_layout() plt.savefig(dir + '/combined_all_par.pdf') plt.close()
def createPlot(name, xlabel, ylabel, xlist, \ list1, list1_5, list1_95, label1, \ list2, list2_5, list2_95, label2, \ list3, list3_5, list3_95, label3, \ list4, list4_5, list4_95, label4, \ list5, list5_5, list5_95, label5, \ list6, list6_5, list6_95, label6, \ list7, list7_5, list7_95, label7, \ list8, list8_5, list8_95, label8): # collecting the data separately in case there are all timeouts for one # particular algorithm for one case xlist_list7, new_list7, new_list7_5, new_list7_95 = [], [], [], [] xlist_list8, new_list8, new_list8_5, new_list8_95 = [], [], [], [] for i, n in enumerate(xlist): if not list7[i] == -1: xlist_list7.append(n) new_list7.append(list7[i]) new_list7_5.append(list7_5[i]) new_list7_95.append(list7_95[i]) if not list8[i] == -1: xlist_list8.append(n) new_list8.append(list8[i]) new_list8_5.append(list8_5[i]) new_list8_95.append(list8_95[i]) list7 = new_list7 list7_5 = new_list7_5 list7_95 = new_list7_95 list8 = new_list8 list8_5 = new_list8_5 list8_95 = new_list8_95 matplotlib.rcParams.update({'font.size': 14}) plt.figure(facecolor='w', edgecolor='k', figsize=(7, 5)) plt.xlabel(xlabel) plt.ylabel(ylabel) xlist = np.array(xlist) # curve for median best fit score1CV, _ = curve_fit(func2D, xlist, list1) score2CV, _ = curve_fit(func2D, xlist, list2) score3CV, _ = curve_fit(func2D, xlist, list3) score4CV, _ = curve_fit(func2D, xlist, list4) score5CV, _ = curve_fit(func2D, xlist, list5) score6CV, _ = curve_fit(func2D, xlist, list6) score7CV, _ = curve_fit(func2D, xlist_list7, list7) score8CV, _ = curve_fit(func2D, xlist_list8, list8) # curve for 5% CI best fit score1_5_CV, _ = curve_fit(func2D, xlist, list1_5) score2_5_CV, _ = curve_fit(func2D, xlist, list2_5) score3_5_CV, _ = curve_fit(func2D, xlist, list3_5) score4_5_CV, _ = curve_fit(func2D, xlist, list4_5) score5_5_CV, _ = curve_fit(func2D, xlist, list5_5) score6_5_CV, _ = curve_fit(func2D, xlist, list6_5) score7_5_CV, _ = curve_fit(func2D, xlist_list7, list7_5) score8_5_CV, _ = curve_fit(func2D, xlist_list8, list8_5) # curve for 95% CI best fit score1_95_CV, _ = curve_fit(func2D, xlist, list1_95) score2_95_CV, _ = curve_fit(func2D, xlist, list2_95) score3_95_CV, _ = curve_fit(func2D, xlist, list3_95) score4_95_CV, _ = curve_fit(func2D, xlist, list4_95) score5_95_CV, _ = curve_fit(func2D, xlist, list5_95) score6_95_CV, _ = curve_fit(func2D, xlist, list6_95) score7_95_CV, _ = curve_fit(func2D, xlist_list7, list7_95) score8_95_CV, _ = curve_fit(func2D, xlist_list8, list8_95) # confidence interval # plt.fill_between(xlist, func2D(xlist, score2_5_CV[0], score2_5_CV[1], score2_5_CV[2]), \ # func2D(xlist, score2_95_CV[0], score2_95_CV[1], score2_95_CV[2]), color='blue', alpha=.5) # plt.fill_between(xlist, func2D(xlist, score3_5_CV[0], score3_5_CV[1], score3_5_CV[2]), \ # func2D(xlist, score3_95_CV[0], score3_95_CV[1], score3_95_CV[2]), color='seagreen', alpha=.5) # plt.fill_between(xlist, func2D(xlist, score1_5_CV[0], score1_5_CV[1], score1_5_CV[2]), \ # func2D(xlist, score1_95_CV[0], score1_95_CV[1], score1_95_CV[2]), color='orangered', alpha=.5) # plt.fill_between(xlist, func2D(xlist, score4_5_CV[0], score4_5_CV[1], score4_5_CV[2]), \ # func2D(xlist, score4_95_CV[0], score4_95_CV[1], score4_95_CV[2]), color='skyblue', alpha=.5) # plt.fill_between(xlist, func2D(xlist, score5_5_CV[0], score5_5_CV[1], score5_5_CV[2]), \ # func2D(xlist, score5_95_CV[0], score5_95_CV[1], score5_95_CV[2]), color='gold', alpha=.5) # plt.fill_between(xlist, func2D(xlist, score6_5_CV[0], score6_5_CV[1], score6_5_CV[2]), \ # func2D(xlist, score6_95_CV[0], score6_95_CV[1], score6_95_CV[2]), color='purple', alpha=.5) newx = np.linspace(10, 1000, 250) # best fit lines plt.plot(newx, func2D(np.array(newx), score3CV[0], score3CV[1], score3CV[2]), '-', color='darkgreen') plt.plot(newx, func2D(np.array(newx), score6CV[0], score6CV[1], score6CV[2]), '-', color='navy') plt.plot(newx, func2D(np.array(newx), score2CV[0], score2CV[1], score2CV[2]), '-', color='mediumseagreen') plt.plot(newx, func2D(np.array(newx), score5CV[0], score5CV[1], score5CV[2]), '-', color='royalblue') plt.plot(newx, func2D(np.array(newx), score1CV[0], score1CV[1], score1CV[2]), '-', color='lightgreen') plt.plot(newx, func2D(np.array(newx), score4CV[0], score4CV[1], score4CV[2]), '-', color='skyblue') plt.plot(newx, func2D(np.array(newx), score7CV[0], score7CV[1], score7CV[2]), '-', color='orange') if not paper: plt.plot(newx, func2D(np.array(newx), score8CV[0], score8CV[1], score8CV[2]), '-', color='red') # points plt.plot(xlist, list3, "s", markersize=4, label=label3, color='darkgreen') plt.plot(xlist, list6, "d", markersize=4, label=label6, color='navy') plt.plot(xlist, list2, 'o', markersize=4, label=label2, color='mediumseagreen') plt.plot(xlist, list5, '^', markersize=4, label=label5, color='royalblue') plt.plot(xlist, list1, '+', markersize=4, label=label1, color='lightgreen') plt.plot(xlist, list4, '*', markersize=4, label=label4, color='skyblue') plt.plot(xlist_list7, list7, '3', markersize=4, label=label7, color='orange') if not paper: plt.plot(xlist_list8, list8, '4', markersize=4, label=label8, color='red') handles, labels = plt.gca().get_legend_handles_labels() order = [4, 2, 0, 5, 3, 1, 6] if not paper: order = [4, 2, 0, 5, 3, 1, 6, 7] plt.xlim(xmin=0, xmax=1000) plt.ylim(ymin=0) plt.grid() plt.legend([handles[idx] for idx in order], [labels[idx] for idx in order]) # plt.legend() plt.tight_layout() filename = dir_name + "/" + name + ".pdf" if paper: filename = dir_name + "/paper_" + name + ".pdf" plt.savefig(filename) plt.close() plt.rcParams.update(plt.rcParamsDefault)
def createHistograms(): # mean num optimal matchings per optimal matching type fig, ax = plt.subplots() ind = np.arange(6) width = 0.2 exps = ['S100', 'S400', 'S700', 'S1000'] exp_bars = [] for i, exp in enumerate(exps): numMinRegret = float(d[exp + 'Av_MinRegret_num'][0]) numEgalitarian = float(d[exp + 'Av_Egalitarian_num'][0]) numBalanced = float(d[exp + 'Av_Balanced_num'][0]) numSeqEqual = float(d[exp + 'Av_SexEqual_num'][0]) numRegretEqual = float(d[exp + 'Av_RegretEqual_num'][0]) numMinSumRegret = float(d[exp + 'Av_MinSumRegret_num'][0]) av_counts = [ numBalanced, numSeqEqual, numEgalitarian, numMinRegret, numRegretEqual, numMinSumRegret ] exp_bars.append( ax.bar(ind + i * width, av_counts, width, color=blues[i])) objects = [ 'Balanced', 'Sex-equal', 'Egalitarian', 'Minimum\nregret', 'Regret-\nequal', 'Min-regret\nsum' ] y_pos = np.arange(len(objects)) plt.grid() plt.xticks(y_pos + 0.3, objects) plt.ylabel('Mean number of stable matchings') plt.xlabel('Type of optimal stable matching') plt.ylim(ymin=0.7) plt.ylim(ymax=100) plt.yscale('log') ax.legend(exp_bars, exps) plt.tight_layout() plt.savefig(dir_name + "/paper_bar_optimal_nums.pdf") plt.close() # average number of matchings which exhibit different numbers of optimal # matchings fig, ax = plt.subplots() ind = np.arange(7) width = 0.2 exps = ['S100', 'S400', 'S700', 'S1000'] exp_bars = [] for i, exp in enumerate(exps): num0 = float(d[exp + 'Av_0_matchingCount'][0]) num1 = float(d[exp + 'Av_1_matchingCount'][0]) num2 = float(d[exp + 'Av_2_matchingCount'][0]) num3 = float(d[exp + 'Av_3_matchingCount'][0]) num4 = float(d[exp + 'Av_4_matchingCount'][0]) num5 = float(d[exp + 'Av_5_matchingCount'][0]) num6 = float(d[exp + 'Av_6_matchingCount'][0]) av_counts = [num0, num1, num2, num3, num4, num5, num6] exp_bars.append( ax.bar(ind + i * width, av_counts, width, color=blues[i])) objects = ['0', '1', '2', '3', '4', '5', '6'] y_pos = np.arange(len(objects)) plt.grid() plt.xticks(y_pos + 0.3, objects) plt.ylabel('Mean number of stable matchings') plt.xlabel('Number of optimal matching criteria satisfied') plt.ylim(ymin=0.07) plt.ylim(ymax=1300) plt.yscale('log') ax.legend(exp_bars, exps) plt.tight_layout() plt.savefig(dir_name + "/paper_bar_num_matchings_num_opt.pdf") plt.close()
def trace_density(self, filepath, savename, directory, skiprows, column_names, show=True): dir = directory + '/%s' % (savename.strip('.yaml')) if not os.path.exists(dir): os.makedirs(dir) if filepath.endswith('.yaml') == True: with open(filepath, 'r') as stream: data_file = yaml.load(stream) stream.close() data = data_file['data'] # parameters = data_file['parameters'] else: # parameters = open(filepath, "r").readlines()[:33] data = np.loadtxt(filepath, delimiter=',', skiprows=skiprows) length = len(data[0]) - (len(column_names) + 3) L_length = 4 #int(data[0][-1]) R_length = 4 #int(data[0][-2]) for i in range(R_length): column_names = np.append(column_names, "R_%i" % (i + 1)) for i in range(L_length): column_names = np.append(column_names, "L_%i" % (i + 1)) column_names = np.append(column_names, "Accepted") # column_names = np.append(column_names,"Rayleigh_length") # column_names = np.append(column_names,"Love_length") params = { 'legend.fontsize': 'x-large', 'figure.figsize': (15, 15), 'axes.labelsize': 25, 'axes.titlesize': 'x-large', 'xtick.labelsize': 25, 'ytick.labelsize': 25 } pylab.rcParams.update(params) # df = pd.DataFrame(data, columns=column_names) df_select = df[["Epi", "Depth", "Strike", "Dip", "Rake"]] par = Get_Paramters() REAL = par.get_unkown() real_v = np.array([ REAL['epi'], REAL['depth_s'], REAL['strike'], REAL['dip'], REAL['rake'] ]) # real_v=np.array([35.2068855191,16848.1405882,99.88000245897199, 77.02994881296266,68.80551508147109]) # real_v=np.array([73.8059395565,26247.7456326,158.92744919732135, 47.46909146946276,-45.69139707143311]) strike, dip, rake = aux_plane(REAL['strike'], REAL['dip'], REAL['rake']) # strike,dip,rake = aux_plane(99.88000245897199,77.02994881296266,68.80551508147109) # strike,dip,rake = aux_plane(158.92744919732135, 47.46909146946276,-45.69139707143311) fig = plt.figure(figsize=(20, 20)) row = 0 for i in df_select: ax1 = plt.subplot2grid((5, 2), (row, 0)) ax1.plot(df_select[i], label=i) # ax1.axhline(y=REAL[df_select], linewidth=0.3, linestyle=':') ax1.set_title("Trace %s" % i, color='b', fontsize=20) ax1.set_xlabel("Iteration") # ax1.set_ylabel("Epicentral ") plt.tight_layout() ax2 = plt.subplot2grid((5, 2), (row, 1)) plt.hist(df_select[i], bins=100) ymin, ymax = ax2.get_ylim() plt.vlines(df_select[i][1], ymin=ymin, ymax=ymax, colors='r', linewidth=3) plt.vlines(real_v[row], ymin=ymin, ymax=ymax, colors='k', linewidth=3) if i == 'Strike': plt.vlines(strike, ymin=ymin, ymax=ymax, colors='g', linewidth=3) if i == 'Dip': plt.vlines(dip, ymin=ymin, ymax=ymax, colors='g', linewidth=3) if i == 'Rake': plt.vlines(rake, ymin=ymin, ymax=ymax, colors='g', linewidth=3) # y, binEdges = np.histogram(df_select[i], bins=100) # bincenters = 0.5 * (binEdges[1:] + binEdges[:-1]) # pylab.plot(bincenters, y, '-',label = "%s" % i) ax2.set_title("Density %s" % i, color='b', fontsize=20) ax2.set_xlabel("N=%i" % (len(df_select[i]))) plt.tight_layout() row += 1 plt.savefig(dir + '/Trace_density.pdf')
def visualize_stats(data, out): f, axs = plt.subplots(2, 2, sharey=False, sharex=False) X = plt.arange(data.shape[0]) width = 0.4 title_fontsize = 10 label_fontsize = 6 # number of detected clusters bars3dsize = axs[0][0].bar(X, data[:, 1], width, color=COLOR1) bars1dsize = axs[0][0].bar(X + width, data[:, 2], width, color=COLOR2) axs[0][0].legend((bars3dsize[0], bars1dsize[0]), ('3D gene clusters', \ '1D gene clusters'), fontsize=title_fontsize) axs[0][0].set_xticks(X + width / 2) axs[0][0].set_xticklabels(map(int, data[:, 0])) axs[0][0].set_ylabel('count') # axs[0][0].set_xlabel(r'$\delta$') axs[0][0].set_title('number of discovered clusters', fontsize=title_fontsize) # average size of detected clusters bars3dsize = axs[0][1].bar(X, data[:, 3], width, color=COLOR1) bars1dsize = axs[0][1].bar(X + width, data[:, 4], width, color=COLOR2) axs[0][1].legend((bars3dsize[0], bars1dsize[0]), ('3D gene clusters', \ '1D gene clusters'), fontsize=title_fontsize) axs[0][1].set_xticks(X + width / 2) axs[0][1].set_xticklabels(map(int, data[:, 0])) axs[0][1].set_ylabel('avg. size') # axs[0][1].set_xlabel(r'$\delta$') axs[0][1].set_title('average size of discovered clusters', fontsize=title_fontsize) axs[0][1].set_yscale('log') # runtime of GraphTeams axs[1][1].scatter(X + width / 2, data[:, 5], color=COLOR1) # axs[1][0].legend(('1D gene clusters', ), fontsize=title_fontsize) axs[1][1].set_xticks(X + width / 2) axs[1][1].set_xticklabels(map(int, data[:, 0])) axs[1][1].set_ylim([0, max(data[:, 5]) + 10]) axs[1][1].set_ylabel('time in mins') axs[1][1].set_xlabel(r'$\delta$') axs[1][1].set_title('computation time of 3D clusters', fontsize=title_fontsize) # spatial gain 3D clusters axs[1][0].bar(X + (width / 2), data[:, 6], width, color=COLOR1) # axs[1][1].legend(('3D gene clusters', ), fontsize=title_fontsize) axs[1][0].set_xticks(X + width / 2) axs[1][0].set_xticklabels(map(int, data[:, 0])) axs[1][0].set_ylabel('avg. number of gained genes') axs[1][0].set_xlabel(r'$\delta$') axs[1][0].set_title('spatial gain of 3D clusters', fontsize=title_fontsize) axs[1][0].set_yscale('log') for axsx in axs: for axsy in axsx: for label in axsy.get_xmajorticklabels(): label.set_rotation(90) label.set_fontsize(label_fontsize) #label.set_horizontalalignment('right') for label in axsy.get_ymajorticklabels(): label.set_fontsize(label_fontsize) plt.tight_layout(pad=0.4, w_pad=0.5, h_pad=1.0) f.savefig(out, format='pdf')
obs_odd_mean + obs_odd_sem, color=odd_colour, alpha=0.2, linewidth=0) ax_obs.axhline(0, linewidth=0.5, color="black") ax_obs.axvline(0, linestyle="--", linewidth=0.5, color="black") plt.title("Observation phase") plt.legend(loc=1) plt.xlabel("Time[s]") plt.ylabel("fT") plt.ylim(-10, 10) plt.xlim(-0.1, 1.0) ax_subset = figure.add_subplot(gs[1]) mne.viz.plot_topomap(np.zeros(274), info, cmap="Greys", vmin=0, vmax=0, mask=ch_selection, mask_params=mask_params, axes=ax_subset, show=False) plt.title("Channel subset") plt.tight_layout(w_pad=0.2, h_pad=0.2) out_path = op.join(img_save, "ERF_ttest_{}.svg".format(key)) plt.savefig(out_path, bbox_inches="tight") plt.show()
def plot_markers(): from matplotlib.colors import LogNorm SMALL_SIZE = 15 MEDIUM_SIZE = 22 plt.rc('font', size=MEDIUM_SIZE) # controls default text sizes plt.rc('axes', titlesize=MEDIUM_SIZE) # fontsize of the axes title plt.rc('axes', labelsize=MEDIUM_SIZE) # fontsize of the x and y labels plt.rc('xtick', labelsize=SMALL_SIZE) # fontsize of the tick labels plt.rc('ytick', labelsize=SMALL_SIZE) # fontsize of the tick labels from matplotlib import rcParams rcParams['font.family'] = 'STIXGeneral' # 'Times New Roman' rcParams['mathtext.fontset'] = 'custom' rcParams['mathtext.rm'] = 'Bitstream Vera Sans' # mpl.rcParams['mathtext.it'] = 'Bitstream Vera Sans:italic' rcParams['mathtext.bf'] = 'Bitstream Vera Sans:bold' # with open(LCmapFile, 'rb') as handle: # LCmap = pickle.load(handle) # xs = [65, 23, 80, 23] # ys = [64, 106, 66, 42] xs = [65, 25, 80, 23] ys = [64, 103, 66, 42] fig = plt.figure(figsize=(20, 10)) # im_ax = fig.add_subplot(1,2,1) im_ax = fig.add_axes([0.00, 0.25, 0.35, 0.55]) interval_map = np.sum(LCmap[:, :, :1], axis=2) im = im_ax.imshow(np.abs(interval_map) + 1e-9, interpolation='none', origin='lower', vmin=1, norm=LogNorm(), cmap="inferno") plt.colorbar(im) # annotate_axis(im, im_ax, interval_map.shape[0]) im_ax.axis('off') im_ax.text(3, 121, 'a', color='w', fontweight='bold', fontsize='30') labels = ['b', 'c', 'd', 'e'] axes = [] subposes = [[0.1, 0.4, 0.4, 0.4], [0.07, 0.4, 0.4, 0.4], [0.55, 0.4, 0.4, 0.4], [0.55, 0.4, 0.4, 0.4]] for i in [2, 3, 5, 6]: axes.append(fig.add_subplot(2, 3, i)) intses = [] for ia, (ix, iy) in enumerate(zip(xs, ys)): circle = plt.Circle((ix, iy), radius=4, color='w', fill=False, linewidth=2) im_ax.add_artist(circle) im_ax.text(ix - 2, iy + 6, labels[ia], color='w', fontweight='bold', fontsize=25) #fontsize is newly added ints = LCmap[iy, ix] intses.append(ints) ID = pipe.get_intensity_dist(ints) bincent = (ID['binsS'] + np.roll(ID['binsS'], 1)) / 2. bincent = np.array(bincent)[1:] guessIc = np.mean(ints) * 0.7 guessIs = np.mean(ints) * 0.3 barwidth = (bincent[-1] - bincent[0]) / len(bincent) popt, _ = curve_fit(MR, bincent, ID['histS'], p0=[guessIc, guessIs]) axes[ia].bar(bincent, ID['histS'], width=barwidth, edgecolor='k', facecolor='lightgrey') axes[ia].plot(bincent, MR(bincent, *popt), 'r--', linewidth=2) # Imean = np.mean(ints) # Istd = np.std(ints) # Ic= np.sqrt(Imean ** 2 - Istd ** 2) # Is = Imean - Ic # axes[ia].plot(bincent, MR(bincent, Ic, Is), 'r--') axes[ia].set_xlabel('Intensity (counts)') axes[ia].tick_params(direction='in', which='both', right=True, top=True) r = popt[0] / popt[1] print r axes[ia].set_ylim([0, 0.165]) axes[ia].text(0.03, 0.9, labels[ia], transform=axes[ia].transAxes, fontweight='bold') props = dict(boxstyle='square', facecolor='w') axes[ia].text(0.97, 0.9, r'$I_C=$%.1f $I_S=$%.1f $I_C/I_S=$%.1f' % (popt[0], popt[1], r), transform=axes[ia].transAxes, ha='right', bbox=props) print 'in order to put the data at the top in a square make 3 text instances with ha = left center and right. Then do plt.Rectangle around all 3. You will need to add some hspace too after you call tight_layout' # axes[ia].text(1.1,0.5, r'$I_C=$%.1f $I_S=$%.1f $I_C/I_S=$%.1f' % (popt[0],popt[1],r), transform=axes[ia].transAxes, ha='center', bbox=props) # if ia <2: axes[ia].text(subposes[ia][0],0.25, r'$\frac{I_C}{I_S}=$%.1f' % r, transform=axes[ia].transAxes) # else: axes[ia].text(subposes[ia][0] + subposes[ia][3] ,0.25, r'$\frac{I_C}{I_S}=$%.1f' % r, ha='right', transform=axes[ia].transAxes) # axes[ia].legend([popt[0], popt[1], r], ['$I_C=$%.1f', '$I_S=$%.1f',r'$\frac{I_C}{I_S}=$%.1f'], loc=3) if ia == 1: axes[ia].set_xlim([20, 110]) plt.tight_layout() for ia in range(4): subax1 = add_subplot_axes(axes[ia], subposes[ia]) subax1.plot(np.linspace(0, 2, len(ints)), intses[ia]) subax1.set_xlabel('Time (s)') # plt.subplots_adjust(left=0.11, right=0.99, top=0.98, bottom=0.14, wspace=0.2) plt.show()
def createDurationPlot(xlist, xlabel, ylabel, \ re_alg_duration_median, re_alg_duration_5, re_alg_duration_95, alg_label, \ re_algAlt_duration_median, re_algAlt_duration_5, re_algAlt_duration_95, algAlt_label, \ re_enum_duration_median, re_enum_duration_5, re_enum_duration_95, enum_label): xlist_alg, xlist_algAlt, xlist_enum = [], [], [] new_re_alg_duration_median, new_re_alg_duration_5, new_re_alg_duration_95 = [], [], [] new_re_algAlt_duration_median, new_re_algAlt_duration_5, new_re_algAlt_duration_95 = [], [], [] new_re_enum_duration_median, new_re_enum_duration_5, new_re_enum_duration_95 = [], [], [] # if paper: # matplotlib.rcParams.update({'font.size': 14}) # collecting the data separately in case we have all timeouts on one particular algorithm for i, n in enumerate(xlist): if not re_alg_duration_median[i] == -1: xlist_alg.append(n) new_re_alg_duration_median.append(re_alg_duration_median[i]) new_re_alg_duration_5.append(re_alg_duration_5[i]) new_re_alg_duration_95.append(re_alg_duration_95[i]) if not re_algAlt_duration_median[i] == -1: xlist_algAlt.append(n) new_re_algAlt_duration_median.append(re_algAlt_duration_median[i]) new_re_algAlt_duration_5.append(re_algAlt_duration_5[i]) new_re_algAlt_duration_95.append(re_algAlt_duration_95[i]) if not re_enum_duration_median[i] == -1: xlist_enum.append(n) new_re_enum_duration_median.append(re_enum_duration_median[i]) new_re_enum_duration_5.append(re_enum_duration_5[i]) new_re_enum_duration_95.append(re_enum_duration_95[i]) re_alg_duration_median = new_re_alg_duration_median re_algAlt_duration_median = new_re_algAlt_duration_median re_enum_duration_median = new_re_enum_duration_median re_alg_duration_5 = new_re_alg_duration_5 re_algAlt_duration_5 = new_re_algAlt_duration_5 re_enum_duration_5 = new_re_enum_duration_5 re_alg_duration_95 = new_re_alg_duration_95 re_algAlt_duration_95 = new_re_algAlt_duration_95 re_enum_duration_95 = new_re_enum_duration_95 # starting the plotting plt.figure() plt.figure(facecolor='w', edgecolor='k', figsize=(7, 5)) plt.xlabel(xlabel) plt.ylabel(ylabel) xlist_alg = np.array(xlist_alg) xlist_algAlt = np.array(xlist_algAlt) xlist_enum = np.array(xlist_enum) # curves algCV, _ = curve_fit(func2D, np.log(xlist_alg), np.log(re_alg_duration_median)) algAltCV, _ = curve_fit(func2D, np.log(xlist_algAlt), np.log(re_algAlt_duration_median)) enumCV, _ = curve_fit(func2D, np.log(xlist_enum), np.log(re_enum_duration_median)) alg_5_CV, _ = curve_fit(func2D, np.log(xlist_alg), np.log(re_alg_duration_5)) algAlt_5_CV, _ = curve_fit(func2D, np.log(xlist_algAlt), np.log(re_algAlt_duration_5)) enum_5_CV, _ = curve_fit(func2D, np.log(xlist_enum), np.log(re_enum_duration_5)) alg_95_CV, _ = curve_fit(func2D, np.log(xlist_alg), np.log(re_alg_duration_95)) algAlt_95_CV, _ = curve_fit(func2D, np.log(xlist_algAlt), np.log(re_algAlt_duration_95)) enum_95_CV, _ = curve_fit(func2D, np.log(xlist_enum), np.log(re_enum_duration_95)) newx_alg = np.logspace(1, 3, 250) newx_algAlt = np.logspace(1, 3, 250) newx_algenum = np.logspace(1, 3, 250) if paper: # plot the best fit curves plt.plot(newx_alg, np.exp(func2D(np.log(newx_alg), algCV[0], algCV[1], algCV[2])), '-', color=blues[1]) plt.plot(newx_algenum, np.exp( func2D(np.log(newx_algenum), enumCV[0], enumCV[1], enumCV[2])), '-', color=blues[3]) # plot the points plt.plot(xlist_alg, re_alg_duration_median, 'o', markersize=4, label=alg_label, color=blues[1]) plt.plot(xlist_enum, re_enum_duration_median, 's', markersize=4, label=enum_label, color=blues[3]) # plot the confidence intervals plt.fill_between(newx_alg, np.exp(func2D(np.log(newx_alg), alg_5_CV[0], alg_5_CV[1], alg_5_CV[2])), \ np.exp(func2D(np.log(newx_alg), alg_95_CV[0], alg_95_CV[1], alg_95_CV[2])), color=blues[0], alpha=0.8) plt.fill_between(newx_algenum, np.exp(func2D(np.log(newx_algenum), enum_5_CV[0], enum_5_CV[1], enum_5_CV[2])), \ np.exp(func2D(np.log(newx_algenum), enum_95_CV[0], enum_95_CV[1], enum_95_CV[2])), color=blues[2], alpha=0.8) else: # plot the best fit curves plt.plot(newx_alg, np.exp(func2D(np.log(newx_alg), algCV[0], algCV[1], algCV[2])), '-', color='skyblue') plt.plot(newx_algAlt, np.exp( func2D(np.log(newx_algAlt), algAltCV[0], algAltCV[1], algAltCV[2])), '-', color='orangered') plt.plot(newx_algenum, np.exp( func2D(np.log(newx_algenum), enumCV[0], enumCV[1], enumCV[2])), '-', color='seagreen') # plot the points plt.plot(xlist_alg, re_alg_duration_median, 'o', markersize=4, label=alg_label, color='skyblue') plt.plot(xlist_algAlt, re_algAlt_duration_median, '*', markersize=4, label=algAlt_label, color='orangered') plt.plot(xlist_enum, re_enum_duration_median, 's', markersize=4, label=enum_label, color='seagreen') plt.plot([0, 1000], [timeout_ms, timeout_ms], "--", label="Timeout", color='red') # plot the confidence intervals plt.fill_between(newx_alg, np.exp(func2D(np.log(newx_alg), alg_5_CV[0], alg_5_CV[1], alg_5_CV[2])), \ np.exp(func2D(np.log(newx_alg), alg_95_CV[0], alg_95_CV[1], alg_95_CV[2])), color='skyblue', alpha=.5) plt.fill_between(newx_algAlt, np.exp(func2D(np.log(newx_algAlt), algAlt_5_CV[0], algAlt_5_CV[1], algAlt_5_CV[2])), \ np.exp(func2D(np.log(newx_algAlt), algAlt_95_CV[0], algAlt_95_CV[1], algAlt_95_CV[2])), color='orangered', alpha=.5) plt.fill_between(newx_algenum, np.exp(func2D(np.log(newx_algenum), enum_5_CV[0], enum_5_CV[1], enum_5_CV[2])), \ np.exp(func2D(np.log(newx_algenum), enum_95_CV[0], enum_95_CV[1], enum_95_CV[2])), color='seagreen', alpha=.5) # plt.plot([100, 1000], [100, 1000000], "--", label="Gradient 4n") plt.xlim(xmin=0, xmax=1000) plt.ylim(ymin=100) plt.yscale('log') plt.grid() plt.legend(loc='upper left') plt.tight_layout() filename = dir_name + "/duration.pdf" if paper: filename = dir_name + "/paper_duration.pdf" plt.savefig(filename) plt.close() plt.rcParams.update(plt.rcParamsDefault)
from matplotlib import pylab if __name__ == '__main__': fh = open('read_lengths.txt') L = [int(x.strip()) for x in fh] fh.close() pylab.hist(L,120, histtype='bar') pylab.tight_layout(); pylab.show()
def plot(index): ts = 1e-12 # time resolution tos = 19e-9 tend = 30e-9 wz1 = -2.0 * np.pi * 0.55e9 wp1 = -2.0 * np.pi * 1.2e9 wp2 = -2.0 * np.pi * 3.4e9 gain = -1.0 * wp1 * wp2 / wz1 if index == 1: simout_filename = 'eq_out1.txt' gs_filename = 'ctle_pulse_response_1.eps' elif index == 2: simout_filename = 'eq_out2.txt' gs_filename = 'ctle_pulse_response_2.eps' elif index == 3: simout_filename = 'eq_out3.txt' gs_filename = 'ctle_pulse_response_3.eps' # load verilog simulation data and get 1d interpolator data1 = np.loadtxt(simout_filename) t = data1[:, 0] yv = data1[:, 1] fn_vlog = interp1d(t, yv) time = np.arange(t[0], t[-1], ts) time2 = np.arange(t[0], tend, ts) time = time[:-1] time2 = time2[:-1] no_sample = len(time2) - len(time) xdata = np.loadtxt('input.txt') xt = np.append(xdata[:, 0], t[-1]) xy = np.append(xdata[:, 1], xdata[:, 1][-1]) fn_x = interp1d(xt, xy) x = fn_x(time) if no_sample > 0: x2 = np.array(list(x) + no_sample * [x[-1]]) else: x2 = x[:no_sample] # ideal transfer function in s-domain t0, y0, x0 = lsim(zpk2tf([wz1], [wp1, wp2], gain), x2, time2) # residual error y_vlog = fn_vlog(time) if no_sample > 0: y_vlog = np.array(list(y_vlog) + no_sample * [y_vlog[-1]]) else: y_vlog = y_vlog[:no_sample] err = y_vlog - y0 print 'Max. residual error = %.1f [mV]' % (max(abs(err[t0 > tos])) * 1000) # plot time, value pairs at which events occur plt.subplot(2, 1, 1) plt.plot(1e9 * t[t > tos], yv[t > tos], 'or', label='Verilog', markersize=5) plt.plot(1e9 * t0[t0 > tos], y0[t0 > tos], label='Analytic expression') plt.xlabel('Time [nsec]') plt.ylabel('Output [V]') plt.axis([tos * 1e9, tend * 1e9, -0.20, 0.20]) #plt.title('Pulse response of CTLE ('+r'$e_{tol}$'+'=1 [mV])') plt.legend(loc=0) plt.subplot(2, 1, 2) plt.plot(1e9 * t0[t0 > tos], 1000 * err[t0 > tos], 'r') plt.xlabel('Time [nsec]') plt.ylabel('Residual error [mV]') plt.axis([tos * 1e9, tend * 1e9, -20, 20]) plt.tight_layout() plt.savefig(gs_filename) plt.close()
plt.plot(ts, label = 'Original') plt.legend(loc = 'best') plt.subplot(4, 1, 2) plt.plot(tendencia, label = 'Tendencia') plt.legend(loc = 'best') plt.subplot(4, 1, 3) plt.plot(sazonal, label = 'Sazionalidade') plt.legend(loc = 'best') plt.subplot(4, 1, 4) plt.plot(aleatorio, label = 'Aleatorio') plt.legend(loc = 'best') plt.tight_layout() #para mostrar o legends # ============================================================================= # Previsão com media # ============================================================================= ts.mean() # ============================================================================= # Média do ultimo ano # ============================================================================= ts['1960-01-01':'1960-12-01'].mean() # ============================================================================= # Media movel
import numpy as np import matplotlib.pylab as plt import pylab from kernel import KernelBasisDE from scipy.special import legendre params = { 'backend': 'ps', 'axes.labelsize': 18, 'text.fontsize': 18, 'axes.titlesize': 18, 'legend.fontsize': 18, 'xtick.labelsize': 18, 'ytick.labelsize': 18, 'text.usetex': True, } pylab.rcParams.update(params) def find_zeros(x, y): r = [] for i in range(len(y) - 1): if y[i] * y[i + 1] < 0: zero = (x[i] * np.abs(y[i + 1]) + x[i + 1] * np.abs(y[i])) / ( np.abs(y[i]) + np.abs(y[i + 1])) r.append(zero) return np.array(r) results = [] N = 1001 il_list = [0, 1, 2] marker_list = ['o', 'x', '+', 'v']
def quicklook_im(image, logAmp=False, show=True, vmin=None, vmax=None, axis=False, anno=None, annos=None, title=None, pupil=False, colormap="YlGnBu_r", mark_star=False, label=None): # MEDIUM_SIZE = 27 # plt.rc('font', size=MEDIUM_SIZE) # controls default text sizes # mgr = plt.get_current_fig_manager() # mgr.full_screen_toggle() # py = mgr.canvas.height() # px = mgr.canvas.width() # dprint((py,px)) # mgr.window.close() if pupil: import Analysis.phot image = image * Analysis.phot.aperture( tp.grid_size / 2, tp.grid_size / 2, tp.grid_size / 2) if show != 'continuous': fig = plt.figure() else: fig = sp.fig vmax = sp.vmax vmin = sp.vmin if title == None: title = r' $I / I^{*}$' ax = fig.add_subplot(111) if logAmp: if np.min(image) <= 0: cax = ax.imshow(image, interpolation='none', origin='lower', vmin=vmin, vmax=vmax, norm=SymLogNorm(linthresh=1e-5), cmap="YlGnBu_r") else: cax = ax.imshow(image, interpolation='none', origin='lower', vmin=vmin, vmax=vmax, norm=LogNorm(), cmap="YlGnBu_r") else: cax = ax.imshow(image, interpolation='none', origin='lower', vmin=vmin, vmax=vmax, cmap=colormap) if axis: annotate_axis(cax, ax, image.shape[0]) if show == 'continuous': fig.canvas.draw() if not sp.cbar: sp.cbar = plt.colorbar( cax) #norm=LogNorm(vmin=cax.min(), vmax=cax.max())) clims = sp.cbar.get_clim() sp.vmax = clims[1] sp.vmin = clims[0] plt.show(block=False) # import time # time.sleep(5.0) else: # cb = plt.colorbar(cax, format=ticker.FuncFormatter(fmt)) cb = plt.colorbar(cax) if axis == None: ax.axis('off') # ax.text(0.84, 0.9, '0.2"', transform=ax.transAxes, fontweight='bold', color='w', ha='center', fontsize=14, family='serif') # ax.plot([0.78, 0.9], [0.87, 0.87],transform=ax.transAxes, color='w', linestyle='-', linewidth=3) # cb.ax.set_title(title, fontsize=16) # if anno: # ax.text(0.05, 0.05, anno, transform=ax.transAxes, fontweight='bold', color='w', fontsize=22) if anno: props = dict(boxstyle='square', facecolor='k', alpha=0.3) ax.text(0.05, 0.05, anno, transform=ax.transAxes, fontweight='bold', color='w', fontsize=22, bbox=props) if label: props = dict(boxstyle='square', facecolor='k', alpha=0.3) ax.text(0.05, 0.9, label, transform=ax.transAxes, fontweight='bold', color='w', fontsize=22, family='serif', bbox=props) # ax.text(0.84, 0.9, '0.5"', transform=ax.transAxes, fontweight='bold', color='w', ha='center', fontsize=14, family='serif') # ax.plot([0.78, 0.9], [0.87, 0.87],transform=ax.transAxes, color='w', linestyle='-', linewidth=3) if mark_star: ax.plot(image.shape[0] / 2, image.shape[1] / 2, marker='*', color='r') plt.tight_layout() # # For plotting on the leftmost screen # figManager = plt.get_current_fig_manager() # # if px=0, plot will display on 1st screen # figManager.window.move(-1920, 0) # figManager.window.setFocus() if show == True: plt.show(block=True)
vi = 100 * 1000 / 3600. z0 = sp.array([0, 0, vi, vi]) # Viento: V = 0 #[m/s] while V <= 20: sol = odeint(bala, z0, t) x = sol[:, 0] y = sol[:, 1] plt.figure(1) plt.plot(x, y) V += 10 # Grafico: plt.legend(['V=0 m/s', 'V=10 m/s', 'V=20 m/s']) plt.title('Trayectoria para distintos vientos') plt.xlabel('X (m)') plt.ylabel('Y (m)') plt.axis([0, 150, 0, 50]) plt.grid(True) plt.tight_layout() # Guardar grafico como png sin abrir una ventana de visualizacion plt1.savefig('Trayectoria para distintos vientos')
def view_datacube(datacube, show=True, logAmp=False, axis=True, vmin=None, vmax=None, width=5): '''axis = anno/None/True''' fig = plt.figure(figsize=(14, 7)) colors = len(datacube) print(colors, width) height = int(np.ceil(colors / float(width))) print(height) peak = np.max(datacube) trough = np.min(datacube) # print peak, trough, 'max' if vmin != None: if peak >= vmin: vmax = peak else: vmin = np.min(datacube) dprint((vmin, peak)) for w in range(colors): ax = fig.add_subplot(height, width, w + 1) if logAmp: if vmin <= 0: # datacube[w] = np.abs(datacube[w] + 1e-9) im = ax.imshow(datacube[w], interpolation='none', origin='lower', vmin=vmin, vmax=vmax, norm=SymLogNorm(linthresh=1e-5), cmap="YlGnBu_r") else: im = ax.imshow(datacube[w], interpolation='none', origin='lower', vmin=vmin, vmax=peak, norm=LogNorm(), cmap="YlGnBu_r") else: im = ax.imshow(datacube[w], interpolation='none', origin='lower', vmin=vmin, vmax=peak, cmap="YlGnBu_r") if axis == 'anno': annotate_axis(im, ax, datacube.shape[1]) if axis == None: plt.axis('off') # ax.grid(color='w', linestyle='--') if axis: # fig.subplots_adjust(bottom=0.1) cbar_ax = fig.add_axes([0.45, 0.15, 0.4, 0.05]) fig.colorbar(im, cax=cbar_ax, orientation='horizontal') # # For plotting on the leftmost screen # figManager = plt.get_current_fig_manager() # # if px=0, plot will display on 1st screen # figManager.window.move(-1920, 0) # figManager.window.setFocus() if show == True: plt.tight_layout() plt.show(block=True)
X_ticks[12] = "Lack of spontaneity (N6)" cl_mean = np.mean(X_org[X_cl_labels == 0], axis=0) n_subs = np.sum(X_cl_labels == 0) ax1 = sns.barplot(X_ticks, cl_mean, palette=my_palette, ax=axarr[0]) ax1.xaxis.set_ticks_position('top') rotateTickLabels(ax1, 45, 'x') ax1.xaxis.set_ticklabels(X_ticks, fontsize=12) ax1.set_xlabel('%i patients' % n_subs, fontsize=16) ax1.set_ylabel("Group 1", fontsize=16) cl_mean = np.mean(X_org[X_cl_labels == 1], axis=0) n_subs = np.sum(X_cl_labels == 1) ax2 = sns.barplot(X_ticks, cl_mean, palette=my_palette, ax=axarr[1]) ax2.set_xlabel('%i patients' % n_subs, fontsize=16) ax2.set_ylabel("Group 2", fontsize=16) cl_mean = np.mean(X_org[X_cl_labels == 2], axis=0) n_subs = np.sum(X_cl_labels == 2) ax3 = sns.barplot(X_ticks, cl_mean, palette=my_palette, ax=axarr[2]) ax3.set_xlabel('%i patients' % n_subs, fontsize=16) ax3.set_ylabel("Group 3", fontsize=16) ax3.tick_params(axis='x', labelbottom='off') # sns.despine(bottom=True) plt.setp(f.axes, ylim=[0, 5.]) # plt.xticks(rotation= 90, fontsize=8) plt.tight_layout(h_pad=3) # plt.savefig('plots/kmeans_3cl_noYaxis.png') plt.show()
axs[3].plot(mjd, df['par_2'], 'o', mec='black') axs[3].set_ylabel('Disk blackbody\nkT (keV)') axs[3].set_ylim(0.15, 0.18) axs[4].plot(mjd, np.sqrt(df['par_3']), 'o', mec='black') axs[4].set_ylabel('Inner disk radius\n' r'R$_{in}d_{10 kpc}/\sqrt{\cos {\theta}}$ (km)') axs[4].set_ylim(380, 900) axs[5].plot(mjd, df['par_4'], 'o', mec='black', mfc='orange') axs[5].set_ylabel('Power-law \nPhoton index') axs[6].plot(mjd, df['par_7'] / 100.0, 'o', mec='black', mfc='orange') axs[6].set_ylabel( 'Unabsorb PL 2-10 keV flux \n($10^{-10}$ erg s$^{-1}$ cm$^{-2}$) ') axs[-1].set_xlabel('MJD') for ax in axs: ax.label_outer() #ax.minorticks_on() ax.xaxis.grid(True) ax.xaxis.grid(which='major', linestyle='--', color='#000000') ax.xaxis.grid(which='minor', linestyle='-.') ax.tick_params(axis="both", which='major', direction='in', length=5) ax.tick_params(axis="both", which='minor', direction='in', length=3) outpdf = 'test.pdf' fig.align_ylabels(axs) plt.tight_layout(pad=2) plt.rcParams["font.family"] = "serif" plt.rcParams["mathtext.fontset"] = "dejavuserif" plt.savefig(outpdf)
def process(f, i): path = 'time_series_images/' + os.path.basename(f) + '.png' if os.path.exists(path): print('Exists, skipping ...') return j = json.loads(open(f).read()) p = j['features'][0]['properties'] # fr = p['water_area_filled_fraction'] t = p['water_area_time'] v1 = p['water_area_value'] v2 = p['water_area_filled'] t_jrc = p['water_area_time_jrc'] v_jrc = p['water_area_value_jrc'] filled_fr = list(zip(v1, v2)) filled_fr = [(o[1] - o[0]) / o[1] for o in filled_fr] mask = ma.masked_greater_equal(filled_fr, 0.5) # t = list(ma.masked_array(t, mask).compressed()) # v1 = list(ma.masked_array(v1, mask).compressed()) # v2 = list(ma.masked_array(v2, mask).compressed()) if not len(t): print('Empty, skipping ...') return years = mdates.YearLocator() # every year v2_filtered = savitzky_golay(np.array(v2), window_size=15, order=4) # v2_filtered = signal.medfilt(v2, 7) # v2_filtered = lowess(v2, t) # v2_filtered = lowess(v2, t, frac=1./50) t = [datetime.datetime.fromtimestamp(tt / 1000) for tt in t] t_jrc = [ datetime.datetime.fromtimestamp(tt_jrc / 1000) for tt_jrc in t_jrc ] s_scale = 'Scale: {:.2f}'.format(p['scale']) + '$m$' s_area = 'Area: {:.2f}'.format( p['area'] / (1000 * 1000)) + '$km^2$, ' + '{:.2f}'.format(100 * p['area'] / (1000 * 1000)) + '$ha$' title = s_scale + ', ' + s_area fig = plt.figure(figsize=(11, 4)) ax = fig.add_subplot(111) ax.xaxis.set_major_locator(years) # fig.autofmt_xdate() ax.set_xlim([datetime.date(1985, 1, 1), datetime.date(2019, 1, 1)]) ax.grid(color='k', linestyle='-', linewidth=1, alpha=0.2) plt.title(title) plt.xticks(rotation=90) ax.plot(t_jrc, v_jrc, marker='.', c='r', markersize=2, linewidth=0, alpha=0.05) ax.plot(t, v1, marker='.', c='b', markersize=2, linewidth=0, alpha=0.05) ax.plot(t, v2, marker='.', c='k', markersize=3, linewidth=0, alpha=0.8) # for SG if len(t) != len(v2_filtered): print('Bad, shapes are not equal, skipping line plotting ...') else: ax.plot(t, v2_filtered, marker='.', c='k', markersize=0, linewidth=2, alpha=0.1) # for LOWESS # v2_filtered_t = [datetime.datetime.fromtimestamp(t / 1000) for t in v2_filtered[:, 0]] # ax.plot(v2_filtered_t, v2_filtered[:, 1], marker='.', c='k', markersize=0, linewidth=2, alpha=0.1) path = 'time_series_images/' + os.path.basename(f) + '.png' print(str(i) + ' ' + path) plt.tight_layout() plt.savefig(path, dpi=150) plt.close()