def plot_points(means_common, means_extra_ms, mean_extra_e, labels): ind = np.arange(len(labels)) # the x locations for the groups width = 0.2 # the width of the bars fig, ax = plt.subplots() rects1 = ax.bar(ind + 0.2, means_extra_ms, width, color='r') rects2 = ax.bar(ind + 0.4, means_common, width, color='g') rects3 = ax.bar(ind + 0.6, means_extra_e, width, color='b') # add some text for labels, title and axes ticks ax.set_ylabel('Number of points') ax.set_title('Point comparison') ax.set_xticks(ind+3*width) ax.set_xticklabels( tuple(labels) ) plt.ylim(ymin = 0, ymax = 100) plt.figlegend( (rects1, rects2, rects3), ('Unique in MATSim route', 'Common points', 'Unique in estimated route'), 'upper right' ) def autolabel(rects): # attach some text labels for rect in rects: height = rect.get_height() ax.text(rect.get_x()+0.6*rect.get_width(), 1.05*height, str(int(height)), ha='center', va='bottom') autolabel(rects1) autolabel(rects2) autolabel(rects3)
def plot_all_dbs_hist(): figure(figsize=(6.5,5)) dbs = ['Heinemann-chemo','Peebo-gluc','Valgepea','HuiAlim','HuiClim','HuiRlim'] dbext = {'Heinemann-chemo':'','Peebo-gluc':'','Valgepea':'','HuiAlim':', A-lim','HuiClim':', C-lim','HuiRlim':', R-lim'} p=subplot(111) for i,db in enumerate(dbs): ps = subplot(231+i) conds,gr,conc_data = datas[""][db] plot_corr_hist(ps,db,conc_data,categories) if db == 'Valgepea': year = 2013 else: year = 2015 ps.annotate("data from %s et. al. %d%s" % (db_name[db],year,dbext[db]),xy=(0.5,0.5),xytext=(-0.87,303),fontsize=6,zorder=10) ps.set_ylim(0,350) ps.set_xlim(-1,1) ps.annotate(chr(65+i),xy=(0.5,0.5),xytext=(-0.87,320),fontsize=10,zorder=10) #assume both subplots have the same categories. handles,labels=ps.get_legend_handles_labels() tight_layout() figlegend(handles,labels,fontsize=6,mode='expand',loc='upper left',bbox_to_anchor=(0.15,0.8,0.7,0.2),ncol=2) subplots_adjust(top=0.9) #fig = gcf() #py.plot_mpl(fig,filename="Growth rate Correlation histograms") savefig('AllDbsGrowthRateCorrelation.pdf') close()
def rcp(results, graphNames): rsltSize = results[0].size / 3 prec = range(0,rsltSize) precN = range(0,rsltSize) recall = range(0, rsltSize) for r in results: for x in range(0,rsltSize): numPos = float(r[0,x][0]) if numPos == 0: prec[x] = 1 else: prec[x] = r[0,x][2] / numPos for x in range(0,rsltSize): recall[x] = r[0,x][2] / float(r[0,x][1]) for x in range(0,rsltSize): precN[x] = 1- prec[x] graph = plt.plot(precN,recall) graphs.append(graph) # plot settings plt.ylabel('Recall') plt.xlabel('1 - Precision') plt.axis([0, 1.0, 0, 1.0]) plt.grid(True) # legend for our graphs plt.figlegend( (graphs), graphNames,'upper left')
def rank_plot(self, rank_thresh = 100, show = True, filename = None): """Returns plot of the frequencies of the attributes, sorted by rank.""" plt.figure() afdf = self.attr_freq_df(rank_thresh) cmap = plt.cm.gist_ncar colors = {i : cmap(int((i + 1) * cmap.N / (self.num_attr_types + 1.0))) for i in range(self.num_attr_types)} fig, (ax1, ax2) = plt.subplots(2, 1, sharex = False, sharey = False, facecolor = 'white') plots_for_legend = [] for (i, t) in enumerate(self.attr_types): afdf_for_type = afdf[afdf['type'] == t] plots_for_legend.append(ax1.plot(afdf_for_type['rank'], np.log10(afdf_for_type['freq']), color = colors[i], linewidth = 2)[0]) ax2.plot(afdf_for_type['rank'], afdf_for_type['cumulative %'], color = colors[i], linewidth = 2) ax1.set_title('Attribute frequencies by type', fontweight = 'bold') ax2.set_xlabel('rank') ax1.set_ylabel('log10(freq)') ax2.set_ylabel('cumulative %') ax2.set_ylim((0, 100)) ax1.grid(True, 'major', color = 'w', linestyle = '-') ax2.grid(True, 'major', color = 'w', linestyle = '-') ax1.set_axisbelow(True) ax2.set_axisbelow(True) ax1.patch.set_facecolor('0.89') ax2.patch.set_facecolor('0.89') plt.figlegend(plots_for_legend, self.attr_types, 'right', fontsize = 10) if filename: plt.savefig(filename) if show: plt.show(block = False)
def plotDif(leap, est, tMag, setName): styleL = ["solid", "dashed", "dotted", "dashdot"] if len(est[0]) == 3: leap = leap[:, :-1] plt.figure() statesP = plt.subplot(211) # for i in range(0,len(est[0]),1): for i in range(0, 1, 4): statesP.plot(tMag, leap[:, i], c="r", ls=styleL[i]) statesP.plot(tMag, est[:, i], c="g", ls=styleL[i]) # statesP.legend() statesP.set_ylabel("Angle [rad]") statesP.set_title("Difference " + setName) difP = plt.subplot(212) dif = leap - est[:, :4] normedDif = np.linalg.norm(dif, axis=1) difP.plot(tMag, normedDif, c="g", ls="-") difP.set_ylabel("Normed Difference [rad]") difP.set_xlabel("Time [sec]") linePerf = mlines.Line2D([], [], color="r", markersize=15, label="Leap") lineEst = mlines.Line2D([], [], color="g", markersize=15, label="Estimated") plt.figlegend((linePerf, lineEst), ("Leap", "Estimated"), loc="upper right")
def scatter_plot_matrix(data,class_labels,filename): plt.figure(figsize=(2000/96, 2000/96), dpi=96) for i in range(0,5): plt.subplot(5,5,5*i+i+1) plt.title(str(data.columns[i]), fontsize=10) min_value = float(np.min(data.ix[:,i])) max_value = float(np.max(data.ix[:,i])) xs = np.linspace(min_value,max_value,500) k=0 for cl in class_list: ind = np.where(class_labels == cl)[0] plot_density(data.ix[ind,i],xs,col[k]) k+=1 k=0 for j in range(0,5): if i!=j: plt.subplot(5,5,5*i+j+1) plt.title(str(data.columns[i]) + " vs " + str(data.columns[j]), fontsize=10) plt.xlabel(data.columns[i], fontsize=10) plt.ylabel(data.columns[j], fontsize=10) for k in range(0,4): ind = np.where(class_labels == class_list[k])[0] plt.scatter(data.ix[ind,i],data.ix[ind,j],s=10,color = col[k],marker = marker_style[k], facecolors = 'none') line=[] for i in range(0,4): line.append(mlines.Line2D([], [], color=col[i], marker=marker_style[i],markersize=10)) plt.tight_layout() plt.figlegend(handles = line, labels = class_list, loc = "upper right") plt.savefig(filename) plt.show() #refer to the saved image for proper visualization
def plot(labels, real_values, *values_list): values = list(values_list) one_step_ahead = [] one_step_ahead.append(real_values) k_step_ahead = [] k_step_ahead.append(real_values) for i in range(0, len(values)/2): one_step_ahead.append(values[i]) k_step_ahead.append(values[len(values)/2 + i]) observations = [] for i in np.arange(1, len(real_values) + 1): observations.append(i) plt.subplot(211) plt.grid(True) plt.xlabel('observations') plt.ylabel('temperature (C)') plt.title('One-step-ahead Data Prediction') plt.ylim(0, 31) lines = [] for lab, val in zip(labels, one_step_ahead): lines.extend(plt.plot(observations, val, label=lab)) plt.subplot(212) plt.grid(True) plt.xlabel('observations') plt.ylabel('temperature (C)') plt.title('K-step-ahead Data Prediction') plt.ylim(0, 31) for lab, val in zip(labels, k_step_ahead): plt.plot(observations, val, label=lab) plt.figlegend(lines, labels, loc = 'lower center', ncol=len(labels), labelspacing=0.) plt.show()
def compare_hr_run(filename1, filename2, descriptor1='1st HR', descriptor2='2nd HR', verbose=False): """ Method to generate a plot comparison between two gpx runs """ import matplotlib.pyplot as plt run1 = GPXCardio(filename1, verbose) run2 = GPXCardio(filename2, verbose) cardio1 = run1.getCardio() cardio2 = run2.getCardio() # Assume 1st file goes first in time def pts_fun(it, hr): t = map(lambda x: (x[0] - it).seconds, hr) hr = map(lambda x: x[1], hr) return t, hr initial_time = cardio1[0][0] f1_time, f1_hr = pts_fun(initial_time, cardio1) f2_time, f2_hr = pts_fun(initial_time, cardio2) lines = plt.plot(f1_time, f1_hr, 'r', f2_time, f2_hr, 'b') plt.ylabel("Heart Rate [bpm]") plt.xlabel("Seconds from begining") plt.title("Heart Rate Monitor Comparison") plt.grid(True) plt.figlegend((lines), (descriptor1, descriptor2), 'lower right') plt.show()
def model_effects_plot(): grs = linspace(0.01,1,15) simple = grs neg = linspace(-0.4,0.01,6) simple = simple/simple.mean() degraded = grs+0.4 degmean = degraded.mean() degraded = degraded/degmean neg_deg = neg+0.4 neg_deg = neg_deg/degmean rate = 1/(1+0.2/grs) rate_effect = grs/rate rate_effect = rate_effect/rate_effect.mean() figure(figsize=(5,3)) ax = subplot(111) ax.plot(grs,simple,'o',label="Unregulated protein - basic model") ax.plot(grs,degraded,'o',label="Unregulated protein - with degradation") ax.plot(neg,neg_deg,'--g') ax.plot(grs,rate_effect,'o',label="Unregulated protein - under decreasing biosynthesis rate") ax.plot(grs,rate,'--r',label="Biosynthesis rate") ax.annotate("degradation\nrate", xy=(-0.4,0),xytext=(-0.4,.6),arrowprops=dict(facecolor='black',shrink=0.05,width=1,headwidth=4),horizontalalignment='center',verticalalignment='center',fontsize=8) ax.set_xlim(xmin=-0.5) ax.set_ylim(ymin=0.) ax.set_xlabel('Growth rate [$h^{-1}$]',fontsize=8) set_ticks(ax,6) ax.spines['left'].set_position('zero') ax.spines['right'].set_color('none') ax.spines['top'].set_color('none') ax.set_ylabel('Normalized protein concentration',fontsize=8) tight_layout() subplots_adjust(top=0.83) handles,labels=ax.get_legend_handles_labels() figlegend(handles,labels,fontsize=6,mode='expand',loc='upper left',bbox_to_anchor=(0.0,0.8,1,0.2),ncol=2,numpoints=1) savefig('TheoreticalModelEffects.pdf') close()
def PlotGraphs(posDistList, negDiNucDist, graphFileName): global threeUtrValues, threeUtrErrors; import matplotlib matplotlib.use('Agg') from matplotlib import pyplot as plt matplotlib.rcParams.update({'font.size': 8}) posMeanValues = [x[0] for x in posDistList.values()] posErrorValues = [x[1] for x in posDistList.values()] negMeanValues = [x[0] for x in negDiNucDist.values()] negErrorValues = [x[1] for x in negDiNucDist.values()] #Two subplots, the axes array is 1-d fig, (ax1, ax2) = plt.subplots(nrows=2) fig.suptitle("Di-nucleotide distribution: 3'UTR vs Generated Files", fontsize=8) labels = posDistList.keys(); eb1, eb2 = distribution_plot(ax1, "Positive Set", posMeanValues, posErrorValues, labels); eb1, eb2 = distribution_plot(ax2, "Negative Set", negMeanValues, negErrorValues, labels); plt.figlegend((eb1, eb2), ("Generated", "3'UTR"), loc = 'lower right'); plt.savefig(graphFileName); plt.close(fig)
def plotMulti(leap, mag, time): """ plot only flex-ext of MCP """ colorL = ["red", "green", "blue", "yellow"] a = plt.subplot(211) state = 0 for i in range(0, len(leap), 1): a.plot(time, leap[i][:, state], c=colorL[i], ls="-") a.plot(time, mag[:, i * 4 + state], c=colorL[i], ls="--") dif = plt.subplot(212) state = 1 for i in range(0, len(leap), 1): dif.plot(time, leap[i][:, state], c=colorL[i], ls="-") dif.plot(time, mag[:, i * 4 + state], c=colorL[i], ls="--") lineInd = mlines.Line2D([], [], color="r", markersize=15, label="Index") lineMid = mlines.Line2D([], [], color="g", markersize=15, label="Middle") lineLeap = mlines.Line2D([], [], color="k", linestyle="-", markersize=15, label="Leap") lineEst = mlines.Line2D([], [], color="k", linestyle="--", markersize=15, label="Estimated") plt.figlegend( (lineInd, lineMid, lineLeap, lineEst), ("Index", "Middle", "Leap", "Estimated"), loc="upper center", ncol=2 )
def overlay_raw_data(raw_dict, individual_raw_dict, mole_graph, individual_graph, sun_results, uuid, out_path): # used because the SUN model uses single letter labels para_map = {"Notch2NL-A": "A", "Notch2NL-B": "B", "Notch2NL-C": "C", "Notch2NL-D": "D", "Notch2": "N"} fig, plots = plt.subplots(len(mole_graph.paralogs), sharey=True, figsize=(12.0, 5.0)) individual_patch = matplotlib.patches.Patch(color=color_palette[0], fill="true") mole_patch = matplotlib.patches.Patch(color=color_palette[1], fill="true") plt.figlegend((individual_patch, mole_patch), ("Individual", "Mole"), loc='upper right', ncol=2) max_gap = max(stop - start for start, stop in mole_graph.paralogs.itervalues()) for i, (p, para) in enumerate(izip(plots, mole_graph.paralogs.iterkeys())): start, stop = mole_graph.paralogs[para] rounded_max_gap = int(math.ceil(1.0 * max_gap / 10000) * 10000) p.axis([start, start + rounded_max_gap, 0, 4]) x_ticks = [start] + range(start + 20000, start + rounded_max_gap + 20000, 20000) p.axes.set_yticks(range(5)) p.axes.set_yticklabels(map(str, range(5)), fontsize=9) p.axes.set_xticks(x_ticks) p.axes.set_xticklabels(["{:.3e}".format(start)] + [str(20000 * x) for x in xrange(1, len(x_ticks))]) starts, stops, vals = zip(*raw_dict[para]) p.hlines(vals, starts, stops, color=color_palette[1], alpha=0.8, linewidth=2.0) if len(sun_results[para_map[para]]) > 0: sun_pos, sun_vals = zip(*sun_results[para_map[para]]) p.vlines(np.asarray(sun_pos), np.zeros(len(sun_pos)), sun_vals, color="#E83535", linewidth=0.5, alpha=0.5) for x in range(1, 4): p.axhline(y=x, ls="--", lw=0.5) p.set_title("{}".format(para)) for i, (p, para) in enumerate(izip(plots, individual_graph.paralogs.iterkeys())): starts, stops, vals = zip(*individual_raw_dict[para]) p.hlines(vals, starts, stops, color=color_palette[0], alpha=0.8, linewidth=2.0) p.set_title("{}".format(para)) fig.subplots_adjust(hspace=0.8) plt.savefig(out_path, format="png", dpi=500) plt.close()
def VisualizeReferenceSpectrum(rf_files, freq_sampling): plt.figure(1, figsize=(5, 4)) handles = [] labels = [] for rf_file in rf_files: ComponentType = itk.ctype('float') Dimension = 2 ImageType = itk.VectorImage[ComponentType, Dimension] reader = itk.ImageFileReader[ImageType].New(FileName=rf_file) reader.Update() image = reader.GetOutput() arr = itk.GetArrayFromImage(image) arr /= arr[:,:,arr.shape[2]/3-arr.shape[2]/5:arr.shape[2]/2+arr.shape[2]/5].max() freq = np.linspace(freq_sampling / 2 / arr.shape[2], freq_sampling / 2, arr.shape[2]) ax = plt.plot(freq, arr[0, 0, :].ravel(), label=rf_file) handles.append(ax[0]) labels.append(rf_file) plt.xlabel('Frequency [Hz]') plt.ylabel('Power spectrum [V]') plt.figlegend(handles, labels, 'upper right') plt.ylim(0.0, 1.0) dirname = os.path.dirname(rf_files[0]) plt.savefig(os.path.join(dirname, 'ReferenceSpectrum.png'), dpi=300) plt.show()
def regional_sa(model, expr, policy={}, nsamples=1000): samples = sample_lhs(model, nsamples) output = evaluate(model, overwrite(samples, policy)) classification = output.apply(expr) classes = sorted(set(classification)) fig, axarr = plt.subplots(1, len(model.uncertainties)) lines = [] for i, u in enumerate(model.uncertainties): for k in classes: indices = [classification[j] == k for j in range(len(classification))] values = [output[j][u.name] for j in range(len(indices)) if indices[j]] sorted_values = sorted(enumerate(values), key=operator.itemgetter(1)) h = axarr[i].plot([v[1] for v in sorted_values], np.arange(len(values))/float(len(values)-1)) lines.append(h[0]) values = [output[j][u.name] for j in range(len(indices))] sorted_values = sorted(enumerate(values), key=operator.itemgetter(1)) h = axarr[i].plot([v[1] for v in sorted_values], np.arange(len(values))/float(len(values)-1)) lines.append(h[0]) axarr[i].set_title(u.name) plt.figlegend(lines[:len(classes)] + [lines[-1]], map(str, classes) + ["Unconditioned"], loc='lower center', ncol=3, labelspacing=0. ) return fig
def med_spread_plot(data, obj_names, fig_name="temp.png", **settings): fig = plt.figure(1) fig.subplots_adjust(hspace=0.5) directory = fig_name.rsplit("/", 1)[0] mkdir(directory) for i, data_map in enumerate(data): meds = data_map["meds"] iqrs = data_map.get("iqrs", None) if iqrs: x = range(len(meds)) index = int(str(len(data))+"1"+str(i+1)) plt.subplot(index) plt.title(obj_names[i]) plt.plot(x, meds, 'b-', x, iqrs, 'r-') plt.ylim((min(iqrs)-1, max(meds)+1)) else: x = range(len(meds)) index = int(str(len(data))+"1"+str(i+1)) plt.subplot(index) plt.title(obj_names[i]) plt.plot(x, meds, 'b-') plt.ylim((min(meds)-1, max(meds)+1)) blue_line = mlines.Line2D([],[], color='blue', label='Median') red_line = mlines.Line2D([],[], color='red', label='IQR') plt.figlegend((blue_line, red_line), ('Median', 'IQR'), loc=9, bbox_to_anchor=(0.5, 0.075), ncol=2) plt.savefig(fig_name) plt.clf()
def percplot(data, perclist, file_name='weight_update_percentile', file_extension='.png', save_im=True, disp_im=False, sety=True): """Plot percentiles of weight update information during 'training1' of RBM object (RBM_m.py) :param data: list of lists, each sublist containing the same percentiles of the weight update matrices :param perclist: list of used percentiles :param file_name: name of optional output file (default: 'weight_update_percentile') :param file_extension: extension of optional output file (default: '.png') :param save_im: whether to save image (default: True) :param disp_im: whether to show image (default: False) :param sety: whether to set the y-range to predefined limits (default: True) :return: nothing, displays plot or saves plot to output file """ fig = plt.figure() lines = plt.plot(data) plt.ylabel('update / weight') plt.xlabel('batch number') if sety: plt.ylim([-0.1, 0.1]) plt.figlegend(lines, perclist, 'upper right') if disp_im: plt.show() if save_im: # Save to (.png) file, remove white border plt.savefig("{}{}".format(file_name, file_extension), bbox_inches='tight') plt.close(fig) # Clear current figure
def __init__(self, window, subplot_num, x_axis, dim=2): ax = window.add_subplot(subplot_num) l = len(x_axis) self.y = ax.plot(range(l), l*[-1,], '-', # Obtain handle to y axis. range(l), l*[-1,], '--', marker='^' ) # Hack: because initially the graph has too few y points, compared to x points, # nothing should be shown on the graph. # The hack is that initial y axis is seto be be below in hell. self.y_data = [] for i in range(dim): self.y_data.append( col.deque(len(x_axis)*[-9999,], # Circular buffer. maxlen=len(x_axis) ) ) # Make plot prettier plt.grid(True) plt.tight_layout() ax.set_ylim(MIN_TEMP, MAX_TEMP) plt.figlegend(self.y, ('tempr', 'ctrl'), 'upper right'); ax.set_ylabel('temperature [C]') # Terrible hack! if subplot_num == 121: ax.set_xlabel('time [s]') else: ax.set_xlabel('time [min]')
def loglogplot(l, title = None, names = None): a = np.array(l).transpose((1,2,0)) mp.figure() lines = mp.loglog(1.0 / a[0], a[1]) if title: mp.suptitle(title) if len(lines) > 1: if names is None: names = range(len(lines)) mp.figlegend(lines, names, 'right')
def plot_timfile(timfile): """Make a plot summarizing a timfile. Input: timfile: A row of info of the timfile to summarize. Output: None """ import matplotlib.pyplot as plt import matplotlib COLOURS = ['k', 'g', 'r', 'b', 'm', 'c', 'y'] ncolours = len(COLOURS) BANDS = ['UHF', 'L-band', 'S-band'] numbands = len(BANDS) toas = get_timfiles_toas(timfile['timfile_id']) obssys_ids = set() for toa in toas: obssys_ids.add(toa['obssystem_id']) obssys_ids = list(obssys_ids) fig = plt.figure() ax = plt.axes((0.1, 0.15, 0.85, 0.75)) lomjd = 70000 himjd = 10000 artists = [] for toa in toas: ind = BANDS.index(toa['band_descriptor']) ymin = float(ind)/numbands ymax = float(ind+1)/numbands cc = COLOURS[obssys_ids.index(toa['obssystem_id']) % ncolours] artists.append(plt.axvline(toa['mjd'], ymin, ymax, c=cc)) himjd = max(himjd, toa['mjd']) lomjd = min(lomjd, toa['mjd']) plt.xlabel("MJD") plt.yticks(np.arange(0.5/numbands, 1, 1.0/numbands), BANDS, rotation=30, va='top') plt.xlim(lomjd, himjd) patches = [] obssystems = [] for ii, obssys_id in enumerate(obssys_ids): cc = COLOURS[ii % ncolours] patches.append(matplotlib.patches.Patch(fc=cc)) obssystems.append(cache.get_obssysinfo(obssys_id)['name']) plt.figlegend(patches, obssystems, 'lower center', ncol=4, prop=dict(size='small')) def change_thickness(event): if event.key == '=': for art in artists: lw = art.get_linewidth() art.set_linewidth(lw+0.5) elif event.key == '-': for art in artists: lw = art.get_linewidth() art.set_linewidth(max(1, lw-0.5)) plt.draw() fig.canvas.mpl_connect('key_press_event', change_thickness)
def makeGraph(choices, flightID, folder): fig, ax = plt.subplots() axes = [ax] axes[0].set_xlabel('Time (minutes)') title = 'Time vs %s for Flight: %s' msg = parameters[choices[0]]['label'] for i in range(1, len(choices)): # Loop to add y-axes & append onto msg axes.append(axes[0].twinx()) msg += ' & ' + parameters[choices[i]]['label'] if i > 1: # Move the last y-axis spine over to the right by 10% of the width of the axes axes[-1].spines['right'].set_position(('axes', 1 + (.1 * (i-1)))) # To make the border of the right-most axis visible, we need to turn the frame # on. This hides the other plots, however, so we need to turn its fill off. axes[-1].set_frame_on(True) axes[-1].patch.set_visible(False) if len(choices) > 2: # Make some space on the right side for the extra y-axis. fig.subplots_adjust(right=(0.75)) COLORS = ('blue', 'red', 'green', 'indigo', 'magenta', 'lightskyblue', 'black', 'salmon', 'chartreuse', 'maroon', 'crimson') for ax, c, color in zip(axes, choices, COLORS): ax.plot(parameters[0]['data'], parameters[c]['data'], color) ax.set_ylabel( '%s (%s)' % (parameters[c]['label'], parameters[c]['units']), color=color ) ax.tick_params(axis='y', colors=color) patches = [] types = ('Stop and Go', 'Touch and Go', 'Go Around', 'Unstable Approach') COLORS = ('lime', 'cyan', 'orange', 'red') for landingType, color in zip(types, COLORS): patches.append(mpatches.Patch(color=color, label = landingType)) for key, a in approaches.items(): for x in a['unstable']: axes[0].axvspan( parameters[0]['data'][x[0]], parameters[0]['data'][x[1]], alpha = 0.8, color='red') if (a['landing-type'] == 'stop-and-go'): landingColor = 'lime' elif (a['landing-type'] == 'touch-and-go'): landingColor = 'cyan' else: landingColor = 'orange' axes[0].axvspan( parameters[0]['data'][a['landing-start']], parameters[0]['data'][a['landing-end']], alpha = 0.8, color = landingColor) plt.title(title % (msg, flightID)) plt.figlegend(handles=patches, labels=types, loc='center right') figure = plt.gcf() figure.set_size_inches(25.6, 16) plt.savefig('%s/%s.png' % (folder, flightID), dpi = 100) plt.clf()
def compare_control(traj, traj_comp, shadow_last=0,plot_columns = 4, order=None): xlabel = 't' if 't' in traj: t = traj['t'] else: print('Time is needed for control comparison') return None if 't' in traj_comp: t_comp = traj_comp['t'] else: print('Time is needed for control comparison') return None columns = [c for c in traj.columns if c != 't'] if not order == None: columns = [columns[i] for i in order] plot_rows = int(len(columns)/plot_columns) if len(columns) % plot_columns > 0: plot_rows += 1 sns.set(font_scale=1.8) sns.set_style("whitegrid") sns.set_style("ticks", {"xtick.major.size": 4, "ytick.major.size": 4}) plt.rcParams['figure.figsize'] = (12, 5 *plot_rows) fig, axes = plt.subplots(nrows=plot_rows, ncols=plot_columns) sns.set_context(font_scale=2) for i, c in enumerate(columns): bg_color = None if i > (len(columns)-shadow_last-1): bg_color = 'lightgray' plt.subplot(plot_rows, plot_columns, i+1, axisbg=bg_color) plt.xlabel(xlabel) plt.ylabel(c) l1, = plt.plot(t, traj[c]) l2, = plt.plot(t_comp, traj_comp[c], c=sns.color_palette()[2]) plt.locator_params(nbins=4) r = (max(traj[c])) - (min(traj[c])) plt.ylim((min(traj[c])-0.1*r, max(traj[c])+0.1*r)) plt.xlim((t.iloc[0], t.iloc[-1])) plt.figlegend([l1,l2],['Optimal control', 'DNN control'],loc = 'upper center', ncol=2,prop={'size':20}, bbox_to_anchor=(0.5, 1.01 )) for i in range(len(columns),plot_rows*plot_columns): plt.subplot(plot_rows,plot_columns,i+1) plt.axis('off') plt.tight_layout() return fig
def visualize2(path): print("Processing path {0}...".format(path)) data = built_converged_data(path) inums_oldpop = dict() inums_random = dict() for wf_name, tasks in data.items(): for task_id, (old_pop_results, random_results) in _sort_dict(tasks): for inum, record in _sort_dict(old_pop_results): if int(inum) in points: dt = inums_oldpop.get(inum, []) dt.append(record["best_avr"]) inums_oldpop[inum] = dt for inum, record in _sort_dict(random_results): if int(inum) in points: dt = inums_random.get(inum, []) dt.append(record["best_avr"]) inums_random[inum] = dt pass result_oldpop = {i: sum(values)/len(values) for i, values in inums_oldpop.items()} result_random = {i: sum(values)/len(values) for i, values in inums_random.items()} result = {i_1: (1 - v_1/v_2)*100 for((i_1, v_1), (i_2, v_2)) in zip_longest(_sort_dict(result_oldpop), _sort_dict(result_random))} plt.figure(figsize=(10, 10)) plt.grid(True) ax = plt.gca() ax.set_xlim(0, len(points)) ax.set_xscale('linear') plt.xticks(range(0, len(points))) ax.set_xticklabels(points) ax.set_title("Overall") plt.yticks([i/5 for i in range(0, 100)]) data = [v for (i, v) in _sort_dict(result)] plt.plot(data, '-bx') h1 = Rectangle((0, 0), 1, 1, fc="r") h2 = Rectangle((0, 0), 1, 1, fc="g") h3 = Rectangle((0, 0), 1, 1, fc="b") plt.suptitle('Average of Best vs Average of Avr', fontsize=20) plt.figlegend([h1, h2, h3], ['with old pop', 'random', 'perf profit'], loc='lower center', ncol=10, labelspacing=0. ) plt.subplots_adjust(hspace=0.5) plt.savefig(path + "overall.png", dpi=128.0, format="png") plt.clf() pass
def customeLegend(self,color_map): legend_map=[[],[]] for sample in color_map: legend_map[0].append(Rectangle((0,0),0,0,visible=False)) legend_map[1].append(sample) for label in color_map[sample]: box=Rectangle((0,0),1,1,color=color_map[sample][label],fill=True) legend_map[0].append(box) legend_map[1].append(label) plt.figlegend(legend_map[0],legend_map[1],loc=9,ncol=len(color_map),prop={'size':8})
def make_diag_figure(self, xnames, ynames): nobj = len(xnames) # initialize subplot size gs, fig = ftools.gen_gridspec_fig( nobj, add_row=False, border=(0.6, 0.6, 0.2, 0.4), space=(0.6, 0.35)) # set up subplot interactions gs_geo = gs.get_geometry() fgrid_r, fgrid_c = tuple(list(range(n)) for n in gs_geo) gs_iter = iproduct(fgrid_r, fgrid_c) # set up kwargs for matplotlib errorbar # prefer to change color, then marker colors_ = ['C{}'.format(cn) for cn in range(10)] markers_ = ['o', 'v', 's', 'P', 'X', 'D', 'H'] # iterate through rows & columns (rows change fastest) # which correspond to different quantities for (i, (ri, ci)) in enumerate(gs_iter): if i >= len(xnames): continue # choose axis ax = fig.add_subplot(gs[ri, ci]) kwarg_cycler = cycler(marker=markers_) * \ cycler(c=colors_) xqty = xnames[i] yqty = ynames[i] # now iterate through results hdulists for (j, (result, kwargs)) in enumerate( zip(self.results, kwarg_cycler)): kwargs['label'] = result[0].header['PLATEIFU'] ax = self._add_log_offset_plot( j, xqty=xqty, yqty=yqty, ax=ax, **kwargs) ax.tick_params(labelsize=5) if i == 0: handles_, labels_ = ax.get_legend_handles_labels() plt.figlegend( handles=handles_, labels=labels_, loc='upper right', prop={'size': 4.}) fig.suptitle('PCA fitting diagnostics', size=8.) return fig
def handle_plot(req): t = time.time() plt.clf() ax = plt.subplot(111) plt.subplots_adjust(top=0.6) for plot_data in req.plots: plot(plot_data) labels = [line.get_label() for line in ax.lines] plt.figlegend(ax.lines, labels, 'upper right') plt.savefig(location + str(t) + '.png') return PlotResponse()
def plotdata(ionofile_in,ionofile_fit,madfile,time1): fig1,axmat =plt.subplots(2,2,facecolor='w',figsize=(10,10)) axvec = axmat.flatten() paramlist = ['ne','te','ti','vo'] paramlisti = ['Ne','Te','Ti','Vi'] paramlistiname = ['$N_e$','$T_e$','$T_i$','$V_i$'] paramunit = ['$m^{-3}$','$^\circ$ K','$^\circ$ K','m/s'] boundlist = [[0.,7e11],[500.,3200.],[500.,2500.],[-500.,500.]] IonoF = IonoContainer.readh5(ionofile_fit) IonoI = IonoContainer.readh5(ionofile_in) gfit = GeoData(readIono,[IonoF,'spherical']) ginp = GeoData(readIono,[IonoI,'spherical']) data1 = GeoData(readMad_hdf5,[madfile,['nel','te','ti','vo','dnel','dte','dti','dvo']]) data1.data['ne']=sp.power(10.,data1.data['nel']) data1.data['dne']=sp.power(10.,data1.data['dnel']) t1,t2 = data1.timelisting()[340] handlist = [] for inum,iax in enumerate(axvec): ploth = rangevsparam(data1,data1.dataloc[0,1:],time1,gkey=paramlist[inum],fig=fig1,ax=iax,it=False) handlist.append(ploth[0]) ploth = rangevsparam(ginp,ginp.dataloc[0,1:],0,gkey=paramlisti[inum],fig=fig1,ax=iax,it=False) handlist.append(ploth[0]) ploth = rangevsparam(gfit,gfit.dataloc[0,1:],0,gkey=paramlisti[inum],fig=fig1,ax=iax,it=False) handlist.append(ploth[0]) iax.set_xlim(boundlist[inum]) iax.set_ylabel('Altitude in km') iax.set_xlabel(paramlistiname[inum]+' in '+paramunit[inum]) # with error bars plt.tight_layout() fig1.suptitle('Comparison Without Error Bars\nPFISR Data Times: {0} to {1}'.format(t1,t2)) plt.subplots_adjust(top=0.9) plt.figlegend( handlist[:3], ['PFISR', 'SimISR Input','SimISR Fit'], loc = 'lower center', ncol=5, labelspacing=0. ) fig2,axmat2 =plt.subplots(2,2,facecolor='w',figsize=(10,10)) axvec2 = axmat2.flatten() handlist2 = [] for inum,iax in enumerate(axvec2): ploth = rangevsparam(data1,data1.dataloc[0,1:],time1,gkey=paramlist[inum],gkeyerr='d'+paramlist[inum],fig=fig2,ax=iax,it=False) handlist2.append(ploth[0]) ploth = rangevsparam(ginp,ginp.dataloc[0,1:],0,gkey=paramlisti[inum],fig=fig2,ax=iax,it=False) handlist2.append(ploth[0]) ploth = rangevsparam(gfit,gfit.dataloc[0,1:],0,gkey=paramlisti[inum],gkeyerr='n'+paramlisti[inum],fig=fig2,ax=iax,it=False) handlist2.append(ploth[0]) iax.set_xlim(boundlist[inum]) iax.set_ylabel('Altitude in km') iax.set_xlabel(paramlistiname[inum]+' in '+paramunit[inum]) plt.tight_layout() fig2.suptitle('Comparison With Error Bars\nPFISR Data Times: {0} to {1}'.format(t1,t2)) plt.subplots_adjust(top=0.9) plt.figlegend( handlist2[:3], ['PFISR', 'SimISR Input','SimISR Fit'], loc = 'lower center', ncol=5, labelspacing=0. ) return (fig1,axvec,handlist,fig2,axvec2,handlist2)
def currdenfig(self, title=None, times=[0], z_index=0, leg_kwargs={}, **kwargs): """Plot current densities of the cell segments at times. **Arguments:** - *title*: Title for the figure - *times*: List of times at which the data should be sampled If multiple times are given, then subfigures will be generated. - *z_index*: z-index at which the current densities are taken - *leg_kwargs*: Dictionary of keyword arguments for :meth:`matplotlib.pyplot.legend` If *leg_kwargs* is *None*, then no legend will be shown. - *\*\*kwargs*: Additional arguments for :meth:`barfig` """ # Process the arguments. xlabel = kwargs.pop('xlabel', 'y-axis index (inlet to outlet)') name_template = self.cell + ('iprimeprime_seg[%i, ' + '%i]' % (z_index+1)) #description = self.get_description(name_template % 1) #unit = self.get_unit(name_template % 1) unit = self.get_unit(name_template % 1) #ylabel = kwargs.pop('ylabel', label_number(description, unit)) ylabel = kwargs.pop('ylabel', label_number("Current density", unit)) # Create the plot. ax = self.barfig(names=[name_template % (i_y+1) for i_y in range(1)], times=times, xlabel=xlabel, ylabel=ylabel, leg_kwargs=None, **kwargs) for a, time in zip(ax, times): a.axhline(self.get_values('cell.iprimeprime', time), linestyle='--', color='k', label='Entire cell') # Decorate. if title is None: if self.n_z == 1: plt.title("Current Distribution of Cell Segments") else: plt.title("Current Distribution of Cell Segments\n" "z-axis index %i (of %i)" % (z_index+1, self.n_z)) if leg_kwargs is not None: loc = leg_kwargs.pop('loc', 'best') if len(ax) == 1: ax[0].legend(loc=loc, **leg_kwargs) else: plt.figlegend(ax[0].lines, **leg_kwargs)
def plotPeriodic(self, measureTypes, yLabel=None, xAxis=None, yAxis=None): self.__checkMeasureTypes(self.__multipleMeasures, measureTypes) self.__checkUnits(self.__multipleMeasures, measureTypes) plt.xlabel('time [s]') lines = [] labels = [] plt.grid(True) for measureType in measureTypes: if not measureType in self.__multipleMeasures: print 'ERROR: Unknown measure %s' % measureType sys.exit() else: name, units, results = self.__multipleMeasures[measureType] for result in results: means, stds, times = result.getValues() relStdValues = result.getRelStdValues() #print "X: ", x #print "Y: ", y measureName, measure, units = self.__getMeasureInfo(measureType) label = '%s (%s %s)' % (measureName, result.getTag(), name) self.__printPeriodicInfo(means, times, stds, relStdValues, label, '') line = plt.plot(times, means) if isinstance(measure, GenericAvgMeasure): #draw average line avgValues = [result.getMeanTotal()] * len(times) avgLine = plt.plot(times, avgValues) avgLabel = 'Avg. of %s: %s %s' % (measureName, result.getMeanTotal(), units) lines.append(avgLine) labels.append(avgLabel) else: label += '\nTotal: %s %s' % (result.getMeanTotal(), units) lines.append(line) labels.append(label) if not yLabel is None: plt.ylabel(yLabel) else: plt.ylabel(units) self.__setAxis(plt, xAxis, yAxis, (min(times), max(times))) plt.figlegend(lines, labels, 'upper right')
def plotPCA(proj3D, X_r, PCs, ligs, colors, csvPath, save_flag): """ Plot the PCA data on 2D plot """ # Main figure fig = plt.figure(figsize=(13, 12), dpi=100) if proj3D: ax = fig.add_subplot(111, projection="3d") for label, col, x, y, z in zip(ligs, colors, X_r[:, 0], X_r[:, 1], X_r[:, 2]): newCol = makeColor(col) Axes3D.scatter(ax, x, y, z, label=label, color=newCol, marker="o", lw=1, s=800) ax.set_xlabel("PC1 (" + '{0:g}'.format(PCs[0]) + " %)", fontsize=30) ax.set_ylabel("PC2 (" + '{0:g}'.format(PCs[1]) + " %)", fontsize=30) ax.set_zlabel("PC3 (" + '{0:g}'.format(PCs[2]) + " %)", fontsize=30) ax.tick_params(axis="both", which="major", labelsize=20) pngPath = csvPath.replace(".csv", "_3D.png") else: ax = fig.add_subplot(111) for label, col, x, y in zip(ligs, colors, X_r[:, 0], X_r[:, 1]): newCol = makeColor(col) ax.scatter(x, y, label=label, color=newCol, marker="o", lw=1, s=800) # ax.annotate(label, xy=(x, y - 0.05), fontsize=10, # ha='center', va='top') ax.set_xlabel("PC1 (" + '{0:g}'.format(PCs[0]) + " %)", fontsize=30) ax.set_ylabel("PC2 (" + '{0:g}'.format(PCs[1]) + " %)", fontsize=30) ax.tick_params(axis="both", which="major", labelsize=30) pngPath = csvPath.replace(".csv", "_2D.png") # figTitle = "PCA on " + csvPath + " (PC1=" + pcVals[0] + ", PC2=" + # pcVals[1] + ")" # ax.text(0.5, 1.04, figTitle, horizontalalignment="center", fontsize=30, # transform=ax.transAxes) # Legend figure fig_legend = plt.figure(figsize=(13, 12), dpi=100) plt.figlegend(*ax.get_legend_handles_labels(), scatterpoints=1, loc="center", fancybox=True, shadow=True, prop={"size": 30}) # Save figures if save flag was used if save_flag: print("\nSAVING figures\n") fig.savefig(pngPath, bbox_inches="tight") fig_legend.savefig(pngPath.replace(".png", "_legend.png")) # Otherwise show the plots else: print("\nSHOWING figures\n") plt.show()
def pltcscan(series): cmodes = sorted(series) f = plt.figure(1) plt.clf() lines = {} i = 0 for i, s in enumerate(cmodes): ser = series[s] lines["%s 1->2" % s] = plt.plot(ser[0], COLORS[i] + LSTYLES[0]) lines["%s 2->1" % s] = plt.plot(ser[1], COLORS[i] + LSTYLES[1]) n = sorted(lines) plt.figlegend([lines[k] for k in n], n, 'upper right') f.canvas.draw()
0.5, r"Maximum Sensor Value (Noise)", ha='left', va='center', rotation='vertical', fontproperties=customfont) # Legend dummy = plt.Rectangle( (0, 0), 1, 1, facecolor=[0.3, 0.3, 0.3], alpha=0.1) # fill_between is not matplotlib artist compatible plt.figlegend([bar, reg_line, dummy], [ r"Sample mean ($1\sigma$)", r"Regression line", r"Prediction band: {0}-RMSE (99.7 \%)".format(std_errors) ], loc='upper center', ncol=5, labelspacing=10.0, fancybox=True, shadow=False) #fig.suptitle("Title centered above all subplots", fontsize=14) #plt.show() #plotname = "noise_threshold_matrix_%d" %matrixID plotname = "noise_threshold_linear_regression" fig.savefig(plotname + ".pdf", pad_inches=0, dpi=fig.dpi) # pdf fig.savefig(plotname + ".pgf", pad_inches=0, dpi=fig.dpi) # pgf plt.close(fig)
plt.title(stage3, fontsize=12, x=0.1, fontweight='demi') # Turn off axis lines and ticks of the big subplot ax.spines['top'].set_color('none') ax.spines['bottom'].set_color('none') ax.spines['left'].set_color('none') ax.spines['right'].set_color('none') ax.tick_params(labelcolor='w', top='off', bottom='off', left='off', right='off') plt.suptitle(fig_title, fontsize=15, color='b') plt.figlegend((wakesal_fig, wakeivm_fig), (condition1, condition2), loc='upper right', fontsize=10, frameon=False) ax.set_xlabel('time (hours)', fontsize=14) ax.set_ylabel('% time spent in stage', fontsize=14) plt.figtext( 0.1, 0.02, str(condition1) + ' at ' + str(stamp1[0]) + ', ' + str(condition2) + ' at ' + str(stamp2[0])) plt.tight_layout() #plt.errorbar(t, mean_y1, yerr = st.plt.xlabel('Time of day (hours)')sem(sorted_values, axis = 0), fmt = 'b-') #plt.errorbar(t, mean_y2, yerr = st.sem(sorted_values1, axis =0), fmt = 'r') plt.hold
for line in file1: variance.append(float(line)) file1.close() [coeffs, xv, yv] = findpowerlaw(bins,count) power.append(coeffs[1]) plt.figure(1) handl, = plt.plot(bins[0:plotmax],count[0:plotmax]) handles.append(handl) plt.figure(2) handles2, =plt.plot(variance) handlesinit.append(handles2) plt.figure(1) plt.xlabel('Money') plt.ylabel('Count') plt.figlegend(handles,('$norm = 0.03$','$norm = 0.3$','$norm = 3$','$norm = 30$'),'upper right') plt.savefig("norm.png") plt.close() plt.figure(2) plt.xlabel('Runs') plt.ylabel('Variance of the wealth distribution') plt.figlegend(handlesinit,('$norm = 0.03$','$norm = 0.3$','$norm = 3$','$norm = 30$'),'upper right') plt.savefig('norminit.png') plt.close()
pop[0].currentImage.save(name, "PNG") #estrutura auxiliar para fazer o grafico fit = [] for i in pop: fit.append(i.fitness) lista[0].append(pop[0].fitness) lista[1].append(np.mean(fit)) return pop, lista if __name__ == '__main__': h1 = Image.open(IMG_NAME).convert("RGB") h1 = h1.resize((200, 200)) pop = [] pop = initPop(h1) x, lista = evolve(pop, h1) x[0].currentImage.save(RESULT_NAME + "f" + str(round(x[0].fitness, 3)) + ".png", "PNG") x[0].currentImage.show() #faz o grafico de fitnessxgeracao, melhor e media da populacao plt.suptitle(RESULT_NAME) plt.xlabel("Geracao") plt.ylabel("Fitnes") leg1, leg2 = plt.plot(lista[0], "r--", lista[1], "g--") plt.figlegend((leg1, leg2), ("Melhor", "Media"), "upper right") plt.show()
def visualise_results_by_agent(results, target_score, file_to_save_results_graph): """Visualises the results of an agent playing""" agents = results.keys() fig, axes = plt.subplots(1, 2, sharex=False, figsize=(14, 9)) # plt.subplots() lines = [] for agent_name in agents: rolling_scores = results[agent_name][1] lines.append(rolling_scores) episodes_seen = len(rolling_scores) time_taken = results[agent_name][2] starting_point = time_taken / len(rolling_scores) time_axes = [ starting_point * (t + 1.0) for t in range(len(rolling_scores)) ] axes[0].plot(range(episodes_seen), rolling_scores) axes[1].plot(time_axes, rolling_scores) max_episodes_seen_by_any_agent = max([ len(rolling_scores) for rolling_scores in [results[agent_name][1] for agent_name in agents] ]) max_time_taken_by_any_agent = max( [results[agent_name][2] for agent_name in agents]) min_score_achieved_by_any_agent = min([ min(rolling_scores) for rolling_scores in [results[agent_name][1] for agent_name in agents] ]) draw_horizontal_line_with_label(axes[0], y_value=target_score, x_min=0, x_max=max_episodes_seen_by_any_agent * 1.02, label="Target \n score") draw_horizontal_line_with_label(axes[1], y_value=target_score, x_min=0, x_max=max_time_taken_by_any_agent * 1.02, label="Target \n score") hide_spines(axes[0], ['right', 'top']) hide_spines(axes[1], ['right', 'top']) set_graph_axis_limits(axes[0], 0, max_episodes_seen_by_any_agent, min_score_achieved_by_any_agent, target_score) set_graph_axis_limits(axes[1], 0, max_time_taken_by_any_agent, min_score_achieved_by_any_agent, target_score) plt.figlegend(lines, labels=agents, loc='lower center', ncol=3, labelspacing=0.) axes[0].set_title("Score vs. Episodes Played", y=1.03, fontweight='bold') axes[1].set_title("Score vs. Time Elapsed", y=1.03, fontweight='bold') set_graph_labels(axes[0], xlabel='Rolling Episode Scores', ylabel='Episode number') set_graph_labels(axes[1], xlabel='Rolling Episode Scores', ylabel='Time in Seconds') if file_to_save_results_graph is not None: plt.savefig(file_to_save_results_graph, bbox_inches="tight") plt.show()
label = round( dataFrameArrayCProbSum[voltage_array.index(xy[0])][0][o] * 100, 2) ax.annotate('%s' % label, xy=xy, textcoords='data', fontsize=17) ax.set_ylim(0, np.amax(dcFractionSumArray) + 0.5) ax.set_ylabel("$\epsilon (V) / \sqrt{P_{DC}} $", fontsize=20) ax.set_xlabel("$U_{set} [mV]$", fontsize=20) ax.tick_params(axis='y', which='major', labelsize=17) ax.tick_params(axis='y', which='minor', labelsize=17) ax.tick_params(axis='x', which='major', labelsize=17) ax.tick_params(axis='x', which='minor', labelsize=17) # ax.set_title("Sum Channel",fontsize=13) #plt.figlegend( lines,labels=labels,loc = 'lower left', labelspacing=2.,prop={'size': 13}) plt.figlegend(lines2, labels=labels2, loc='lower left', labelspacing=0.1, prop={'size': 15}) ##fig2, (ax2, ax3) = plt.subplots(nrows=2, ncols=1) # two axes on figure #ax2.plot(x, z) #ax3.plot(x, -z) #print(dcFractionArray) #plt.subplots_adjust(left=0.08, right=0.97, top=0.85, bottom=0.06, hspace=0.48, wspace=0.23) #fig0.suptitle("Significance") plt.show() #ax0[1,0].plot([1, 2, 3, 4])
def plot_data(tempo_results, xkey, ykey, interactive=True, mark_peri=False, show_legend=True): subplot = 1 numsubplots = 2 global axes axes = [] global ax_types ax_types = [] global ax_phase_wraps ax_phase_wraps = [] global ax_jump_ranges ax_jump_ranges = [] handles = [] labels = [] for usepostfit in [False, True]: # Always use pre, then post TOAcount = 0 # All subplots are in a single column if subplot == 1: axes.append(plt.subplot(numsubplots, 1, subplot)) else: axes.append(plt.subplot(numsubplots, 1, subplot, sharex=axes[0])) if usepostfit: ax_types.append('post') else: ax_types.append('pre') ax_phase_wraps.append([]) ax_jump_ranges.append([]) # set tick formatter to not use scientific notation or an offset tick_formatter = matplotlib.ticker.ScalarFormatter(useOffset=False) tick_formatter.set_scientific(False) axes[-1].xaxis.set_major_formatter(tick_formatter) xmin, xmax = axes[0].get_xlim() for ii, (lo, hi) in enumerate(tempo_results.freqbands): freq_label = get_freq_label(lo, hi) resids = tempo_results.residuals[freq_label] xlabel, xdata = resids.get_xdata(xkey) ylabel, ydata, yerr = resids.get_ydata(ykey, usepostfit, tempo_results.phase_wraps) if len(xdata): # Plot the residuals handle = plt.errorbar(xdata, ydata, yerr=yerr, fmt='.', \ label=freq_label, picker=5, c=colors[len(tempo_results.freqbands)][ii]) if subplot == 1: handles.append(handle[0]) labels.append(freq_label) TOAcount += xdata.size # Plot phase wraps text_offset = offset_copy(axes[-1].transData, x=5, y=-10, units='dots') if usepostfit: pw = tempo_results.phase_wraps elif tempo_history.current_index > 0: pw = tempo_history.tempo_results[tempo_history.current_index - 1].phase_wraps else: pw = [] for wrap_index in pw: wrap_mjd_hi = tempo_results.ordered_MJDs[wrap_index] if wrap_index > 0: wrap_mjd_lo = tempo_results.ordered_MJDs[wrap_index - 1] else: wrap_mjd_lo = wrap_mjd_hi if xkey == 'mjd': wrap_x = 0.5 * (wrap_mjd_hi + wrap_mjd_lo) elif xkey == 'year': wrap_x = mjd_to_year(0.5 * (wrap_mjd_hi + wrap_mjd_lo)) elif xkey == 'numtoa': wrap_x = wrap_index - 0.5 else: break wrap_color = {'pre': 'pink', 'post': 'red'} wrp = plt.axvline(wrap_x, ls=':', label='_nolegend_', color=wrap_color[ax_types[-1]], lw=1.5) wrp_txt = plt.text(wrap_x, axes[-1].get_ylim()[1], "%+d" % pw[wrap_index], transform=text_offset, size='x-small', color=wrap_color[ax_types[-1]]) ax_phase_wraps[-1].append([wrp, wrp_txt]) # set up span selector for setting new jump ranges options.jump_spans[ax_types[-1]] = SpanSelector( axes[-1], select_jump_range, 'horizontal', useblit=True, rectprops=dict(alpha=0.5, facecolor='orange')) options.jump_spans[ax_types[-1]].visible = options.jump_mode if subplot > 1: axes[0].set_xlim((xmin, xmax)) # Finish off the plot plt.axhline(0, ls='--', label="_nolegend_", c='k', lw=0.5) axes[-1].ticklabel_format(style='plain', axis='x') if mark_peri and hasattr(tempo_results.outpar, 'BINARY'): # Be sure to check if pulsar is in a binary # Cannot mark passage of periastron if not a binary if usepostfit: binpsr = binary_psr.binary_psr(tempo_results.outpar.FILE) else: binpsr = binary_psr.binary_psr(tempo_results.inpar.FILE) xmin, xmax = axes[0].get_xlim() mjd_min = tempo_results.min_TOA mjd_max = tempo_results.max_TOA guess_mjds = np.arange(mjd_max + binpsr.par.PB, \ mjd_min - binpsr.par.PB, -binpsr.par.PB) for mjd in guess_mjds: peri_mjd = binpsr.most_recent_peri(float(mjd)) if xkey == 'mjd': plt.axvline(peri_mjd, ls=':', label='_nolegend_', c='k', lw=0.5) elif xkey == 'year': print "plotting peri passage" plt.axvline(mjd_to_year(peri_mjd), ls=':', label='_nolegend_', c='k', lw=0.5) axes[0].set_xlim((xmin, xmax)) plt.xlabel(xlabel) plt.ylabel(ylabel) subplot += 1 # Plot jump ranges for jstart, jend in tempo_results.jump_ranges: plot_jump_range((jstart, jend)) # axes[-1].set_ylim((ymin, ymax)) if numsubplots > 1: # Increase spacing between subplots. plt.subplots_adjust(hspace=0.25) # Write name of input files used for timing on figure if interactive: fntext = "Solution %d of %d, TOA file: %s, Parameter file: %s" % \ (tempo_history.current_index+1, tempo_history.get_nsolutions(), tempo_results.intimfn, tempo_results.inparfn) figure_text = plt.figtext(0.01, 0.01, fntext, verticalalignment='bottom', horizontalalignment='left') # Make the legend and set its visibility state leg = plt.figlegend(handles, labels, 'upper right') leg.set_visible(show_legend) leg.legendPatch.set_alpha(0.5) axes[0].xaxis.tick_top() plt.setp(axes[0].get_yticklabels()[0], visible=False) plt.setp(axes[1].get_yticklabels()[-1], visible=False) plt.setp(axes[0].get_yticklabels()[-1], visible=False) plt.setp(axes[1].get_yticklabels()[0], visible=False) plt.subplots_adjust(wspace=0.05, hspace=0.0, left=0.15, bottom=0.1, right=0.8, top=0.9) nms = [] fitmes = [] for b in tempo_history.get_parfile(): if tempo_history.get_parfile()[b].fit == None: tempo_history.get_parfile()[b].fit = 0 if not any(b in s for s in tempy_io.no_fit_pars): nms.append(b) fitmes.append(tempo_history.get_parfile()[b].fit) rax = plt.axes([0.85, 0.1, 0.1, 0.8]) rax.set_frame_on(False) options.fitcheck = CheckButtons(rax, nms, fitmes) options.fitcheck.on_clicked(update_fit_flag) redrawplot()
def plot_line(x, y): plt.plot(np.unique(x), np.poly1d(np.polyfit(x, y, 1))(np.unique(x))) numbers = [1000003, 2000003, 4000037, 8000009, 16000057, 32000011, 64000031, 128000003, 256000001, 512000009, 1024000009,2048000011] partie1_pire_cas = 6 * np.array(numbers) - 6 partie1_millieur_cas = [6,6,6,6,6,6,6,6,6,6,6,6] plt.title('Pire cas VS Millieur cas') line1, = plt.plot(numbers, partie1_millieur_cas, 'go') line2, = plt.plot(numbers, partie1_pire_cas, 'ro') plot_line(numbers, partie1_millieur_cas) plot_line(numbers, partie1_pire_cas) plt.figlegend((line1, line2), ('millieur', 'pire'), 'upper left') plt.xlabel('nombre') plt.ylabel('temps') plt.savefig('Pire cas VS Millieur cas.png') plt.clf() #plt.show() partie1 = [0.017629, 0.020659, 0.040898, 0.081364, 0.162702, 0.327618, 0.653843, 1.319670, 2.627742, 5.220003, 10.406829, 20.833496] plt.title('Algorithme1') plt.plot(numbers, partie1, 'bo') plot_line(numbers, partie1) plt.xlabel('nombre') plt.ylabel('temps') plt.savefig('Algorithme1')
def test_all(): if pdf_output: from matplotlib.backends.backend_pdf import PdfPages pdf = PdfPages("test_dotplot.pdf") else: pdf = None # Basic dotplot with points only plt.clf() points = range(20) ax = plt.axes() fig = dot_plot(points, ax=ax) ax.set_title("Basic horizontal dotplot") close_or_save(pdf, fig) # Basic vertical dotplot plt.clf() points = range(20) ax = plt.axes() fig = dot_plot(points, ax=ax, horizontal=False) ax.set_title("Basic vertical dotplot") close_or_save(pdf, fig) # Tall and skinny plt.figure(figsize=(4,12)) ax = plt.axes() vals = np.arange(40) fig = dot_plot(points, ax=ax) ax.set_title("Tall and skinny dotplot") ax.set_xlabel("x axis label") close_or_save(pdf, fig) # Short and wide plt.figure(figsize=(12,4)) ax = plt.axes() vals = np.arange(40) fig = dot_plot(points, ax=ax, horizontal=False) ax.set_title("Short and wide dotplot") ax.set_ylabel("y axis label") close_or_save(pdf, fig) # Tall and skinny striped dotplot plt.figure(figsize=(4,12)) ax = plt.axes() points = np.arange(40) fig = dot_plot(points, ax=ax, striped=True) ax.set_title("Tall and skinny striped dotplot") ax.set_xlim(-10, 50) close_or_save(pdf, fig) # Short and wide striped plt.figure(figsize=(12,4)) ax = plt.axes() points = np.arange(40) fig = dot_plot(points, ax=ax, striped=True, horizontal=False) ax.set_title("Short and wide striped dotplot") ax.set_ylim(-10, 50) close_or_save(pdf, fig) # Basic dotplot with few points plt.figure() ax = plt.axes() points = np.arange(4) fig = dot_plot(points, ax=ax) ax.set_title("Basic horizontal dotplot with few lines") close_or_save(pdf, fig) # Basic dotplot with few points plt.figure() ax = plt.axes() points = np.arange(4) fig = dot_plot(points, ax=ax, horizontal=False) ax.set_title("Basic vertical dotplot with few lines") close_or_save(pdf, fig) # Manually set the x axis limits plt.figure() ax = plt.axes() points = np.arange(20) fig = dot_plot(points, ax=ax) ax.set_xlim(-10, 30) ax.set_title("Dotplot with adjusted horizontal range") close_or_save(pdf, fig) # Left row labels plt.clf() ax = plt.axes() lines = ["ABCDEFGH"[np.random.randint(0, 8)] for k in range(20)] points = np.random.normal(size=20) fig = dot_plot(points, lines=lines, ax=ax) ax.set_title("Dotplot with user-supplied labels in the left margin") close_or_save(pdf, fig) # Left and right row labels plt.clf() ax = plt.axes() points = np.random.normal(size=20) lines = ["ABCDEFGH"[np.random.randint(0, 8)] + "::" + str(k+1) for k in range(20)] fig = dot_plot(points, lines=lines, ax=ax, split_names="::") ax.set_title("Dotplot with user-supplied labels in both margins") close_or_save(pdf, fig) # Both sides row labels plt.clf() ax = plt.axes([0.1, 0.1, 0.88, 0.8]) points = np.random.normal(size=20) lines = ["ABCDEFGH"[np.random.randint(0, 8)] + "::" + str(k+1) for k in range(20)] fig = dot_plot(points, lines=lines, ax=ax, split_names="::", horizontal=False) txt = ax.set_title("Vertical dotplot with user-supplied labels in both margins") txt.set_position((0.5, 1.06)) close_or_save(pdf, fig) # Custom colors and symbols plt.clf() ax = plt.axes([0.1, 0.07, 0.78, 0.85]) points = np.random.normal(size=20) lines = np.kron(range(5), np.ones(4)).astype(np.int32) styles = np.kron(np.ones(5), range(4)).astype(np.int32) #marker_props = {k: {"color": "rgbc"[k], "marker": "osvp"[k], # "ms": 7, "alpha": 0.6} for k in range(4)} # python 2.6 compat, can be removed later marker_props = dict((k, {"color": "rgbc"[k], "marker": "osvp"[k], "ms": 7, "alpha": 0.6}) for k in range(4)) fig = dot_plot(points, lines=lines, styles=styles, ax=ax, marker_props=marker_props) ax.set_title("Dotplot with custom colors and symbols") close_or_save(pdf, fig) # Basic dotplot with symmetric intervals plt.clf() ax = plt.axes() points = range(20) fig = dot_plot(points, intervals=np.ones(20), ax=ax) ax.set_title("Dotplot with symmetric intervals") close_or_save(pdf, fig) # Basic dotplot with symmetric intervals, pandas inputs. plt.clf() ax = plt.axes() points = pd.Series(range(20)) intervals = pd.Series(np.ones(20)) fig = dot_plot(points, intervals=intervals, ax=ax) ax.set_title("Dotplot with symmetric intervals (Pandas inputs)") close_or_save(pdf, fig) # Basic dotplot with nonsymmetric intervals plt.clf() ax = plt.axes() points = np.arange(20) intervals = [(1, 3) for i in range(20)] fig = dot_plot(points, intervals=intervals, ax=ax) ax.set_title("Dotplot with nonsymmetric intervals") close_or_save(pdf, fig) # Vertical dotplot with nonsymmetric intervals plt.clf() ax = plt.axes() points = np.arange(20) intervals = [(1, 3) for i in range(20)] fig = dot_plot(points, intervals=intervals, ax=ax, horizontal=False) ax.set_title("Vertical dotplot with nonsymmetric intervals") close_or_save(pdf, fig) # Dotplot with nonsymmetric intervals, adjust line properties plt.clf() ax = plt.axes() points = np.arange(20) intervals = [(1, 3) for x in range(20)] line_props = {0: {"color": "lightgrey", "solid_capstyle": "round"}} fig = dot_plot(points, intervals=intervals, line_props=line_props, ax=ax) ax.set_title("Dotplot with custom line properties") close_or_save(pdf, fig) # Dotplot with two points per line and a legend plt.clf() ax = plt.axes([0.1, 0.1, 0.75, 0.8]) points = 5*np.random.normal(size=40) lines = np.kron(range(20), (1,1)) intervals = [(1,3) for k in range(40)] styles = np.kron(np.ones(20), (0,1)).astype(np.int32) styles = [["Cat", "Dog"][i] for i in styles] fig = dot_plot(points, intervals=intervals, lines=lines, styles=styles, ax=ax, stacked=True) handles, labels = ax.get_legend_handles_labels() leg = plt.figlegend(handles, labels, "center right", numpoints=1, handletextpad=0.0001) leg.draw_frame(False) ax.set_title("Dotplot with two points per line") close_or_save(pdf, fig) # Dotplot with two points per line and a legend plt.clf() ax = plt.axes([0.1, 0.1, 0.75, 0.8]) fig = dot_plot(points, intervals=intervals, lines=lines, styles=styles, ax=ax, stacked=True, styles_order=["Dog", "Cat"]) handles, labels = ax.get_legend_handles_labels() leg = plt.figlegend(handles, labels, "center right", numpoints=1, handletextpad=0.0001) leg.draw_frame(False) ax.set_title("Dotplot with two points per line (reverse order)") close_or_save(pdf, fig) # Vertical dotplot with two points per line and a legend plt.clf() ax = plt.axes([0.1, 0.1, 0.75, 0.8]) points = 5*np.random.normal(size=40) lines = np.kron(range(20), (1,1)) intervals = [(1,3) for k in range(40)] styles = np.kron(np.ones(20), (0,1)).astype(np.int32) styles = [["Cat", "Dog"][i] for i in styles] fig = dot_plot(points, intervals=intervals, lines=lines, styles=styles, ax=ax, stacked=True, horizontal=False) handles, labels = ax.get_legend_handles_labels() leg = plt.figlegend(handles, labels, "center right", numpoints=1, handletextpad=0.0001) leg.draw_frame(False) ax.set_title("Vertical dotplot with two points per line") close_or_save(pdf, fig) # Vertical dotplot with two points per line and a legend plt.clf() ax = plt.axes([0.1, 0.1, 0.75, 0.8]) styles_order = ["Dog", "Cat"] fig = dot_plot(points, intervals=intervals, lines=lines, styles=styles, ax=ax, stacked=True, horizontal=False, styles_order=styles_order) handles, labels = ax.get_legend_handles_labels() lh = dict(zip(labels, handles)) handles = [lh[l] for l in styles_order] leg = plt.figlegend(handles, styles_order, "center right", numpoints=1, handletextpad=0.0001) leg.draw_frame(False) ax.set_title("Vertical dotplot with two points per line (reverse order)") close_or_save(pdf, fig) # Vertical dotplot with two points per line and a legend plt.clf() ax = plt.axes([0.1, 0.1, 0.75, 0.8]) points = 5*np.random.normal(size=40) lines = np.kron(range(20), (1,1)) intervals = [(1,3) for k in range(40)] styles = np.kron(np.ones(20), (0,1)).astype(np.int32) styles = [["Cat", "Dog"][i] for i in styles] fig = dot_plot(points, intervals=intervals, lines=lines, styles=styles, ax=ax, stacked=True, striped=True, horizontal=False) handles, labels = ax.get_legend_handles_labels() leg = plt.figlegend(handles, labels, "center right", numpoints=1, handletextpad=0.0001) leg.draw_frame(False) plt.ylim(-20, 20) ax.set_title("Vertical dotplot with two points per line") close_or_save(pdf, fig) # Dotplot with color-matched points and intervals plt.clf() ax = plt.axes([0.1, 0.1, 0.75, 0.8]) points = 5*np.random.normal(size=40) lines = np.kron(range(20), (1,1)) intervals = [(1,3) for k in range(40)] styles = np.kron(np.ones(20), (0,1)).astype(np.int32) styles = [["Cat", "Dog"][i] for i in styles] marker_props = {"Cat": {"color": "orange"}, "Dog": {"color": "purple"}} line_props = {"Cat": {"color": "orange"}, "Dog": {"color": "purple"}} fig = dot_plot(points, intervals=intervals, lines=lines, styles=styles, ax=ax, stacked=True, marker_props=marker_props, line_props=line_props) handles, labels = ax.get_legend_handles_labels() leg = plt.figlegend(handles, labels, "center right", numpoints=1, handletextpad=0.0001) leg.draw_frame(False) ax.set_title("Dotplot with color-matched points and intervals") close_or_save(pdf, fig) # Dotplot with color-matched points and intervals plt.clf() ax = plt.axes([0.1, 0.1, 0.75, 0.8]) points = 5*np.random.normal(size=40) lines = np.kron(range(20), (1,1)) intervals = [(1,3) for k in range(40)] styles = np.kron(np.ones(20), (0,1)).astype(np.int32) styles = [["Cat", "Dog"][i] for i in styles] marker_props = {"Cat": {"color": "orange"}, "Dog": {"color": "purple"}} line_props = {"Cat": {"color": "orange"}, "Dog": {"color": "purple"}} fig = dot_plot(points, intervals=intervals, lines=lines, styles=styles, ax=ax, stacked=True, marker_props=marker_props, line_props=line_props, horizontal=False) handles, labels = ax.get_legend_handles_labels() leg = plt.figlegend(handles, labels, "center right", numpoints=1, handletextpad=0.0001) leg.draw_frame(False) ax.set_title("Dotplot with color-matched points and intervals") close_or_save(pdf, fig) # Dotplot with sections plt.clf() ax = plt.axes() points = range(30) lines = np.kron(range(15), (1,1)).astype(np.int32) styles = np.kron(np.ones(15), (0,1)).astype(np.int32) sections = np.kron((0,1,2), np.ones(10)).astype(np.int32) sections = [["Axx", "Byy", "Czz"][k] for k in sections] fig = dot_plot(points, lines=lines, styles=styles, sections=sections, ax=ax) ax.set_title("Dotplot with sections") close_or_save(pdf, fig) # Vertical dotplot with sections plt.clf() ax = plt.axes([0.1,0.1,0.9,0.75]) points = range(30) lines = np.kron(range(15), (1,1)).astype(np.int32) styles = np.kron(np.ones(15), (0,1)).astype(np.int32) sections = np.kron((0,1,2), np.ones(10)).astype(np.int32) sections = [["Axx", "Byy", "Czz"][k] for k in sections] fig = dot_plot(points, lines=lines, styles=styles, sections=sections, ax=ax, horizontal=False) txt = ax.set_title("Vertical dotplot with sections") txt.set_position((0.5, 1.08)) close_or_save(pdf, fig) # Reorder sections plt.clf() ax = plt.axes() points = range(30) lines = np.kron(range(15), (1,1)).astype(np.int32) styles = np.kron(np.ones(15), (0,1)).astype(np.int32) sections = np.kron((0,1,2), np.ones(10)).astype(np.int32) sections = [["Axx", "Byy", "Czz"][k] for k in sections] fig = dot_plot(points, lines=lines, styles=styles, sections=sections, ax=ax, section_order=["Byy", "Axx", "Czz"]) ax.set_title("Dotplot with sections in specified order") close_or_save(pdf, fig) # Reorder the lines. plt.figure() ax = plt.axes() points = np.arange(4) lines = ["A", "B", "C", "D"] line_order = ["B", "C", "A", "D"] fig = dot_plot(points, lines=lines, line_order=line_order, ax=ax) ax.set_title("Dotplot with reordered lines") close_or_save(pdf, fig) # Format labels plt.clf() points = range(20) lines = ["%d::%d" % (i, 100+i) for i in range(20)] fmt_left = lambda x : "lft_" + x fmt_right = lambda x : "rgt_" + x ax = plt.axes() fig = dot_plot(points, lines=lines, ax=ax, split_names="::", fmt_left_name=fmt_left, fmt_right_name=fmt_right) ax.set_title("Horizontal dotplot with name formatting") close_or_save(pdf, fig) # Right names only plt.clf() points = range(20) lines = ["%d::%d" % (i, 100+i) for i in range(20)] ax = plt.axes() fig = dot_plot(points, lines=lines, ax=ax, split_names="::", show_names="right") ax.set_title("Show right names only") close_or_save(pdf, fig) # Dotplot with different numbers of points per line plt.clf() ax = plt.axes([0.1, 0.1, 0.75, 0.8]) points = 5*np.random.normal(size=40) lines = [] ii = 0 while len(lines) < 40: for k in range(np.random.randint(1, 4)): lines.append(ii) ii += 1 styles = np.kron(np.ones(20), (0,1)).astype(np.int32) styles = [["Cat", "Dog"][i] for i in styles] fig = dot_plot(points, lines=lines, styles=styles, ax=ax, stacked=True) handles, labels = ax.get_legend_handles_labels() leg = plt.figlegend(handles, labels, "center right", numpoints=1, handletextpad=0.0001) leg.draw_frame(False) ax.set_title("Dotplot with different numbers of points per line") close_or_save(pdf, fig) if pdf_output: pdf.close() plt.close('all')
def on_event(self, event): """ Some keyboard events for testing purposes (not used during training) """ if event.type == pygame.QUIT: self._running = False quit() if event.type == pygame.KEYUP: if event.key == pygame.K_SPACE: # PAUSE if self._paused: # Unpause the simulation self._paused = False else: # When simulation is paused, a plot of the errors is shown to the user # Transpose the error matrices to plot more easily beacon_error = np.transpose(self.delta_beacon) kalman_error = np.transpose(self.delta_kalman) odometry_error = np.transpose(self.delta_odometry) # Find out how many measurements x = np.linspace(1, len(beacon_error[0]), len(beacon_error[0])) plt.figure() plt.title("Deviation from actual pose") # Plot the X errors plt.subplot(3, 1, 1) plt.plot(x, beacon_error[0], '-', x, kalman_error[0], '-', x, odometry_error[0], '-', linewidth=2) plt.ylabel('X-coordinate') # Plot the Y errors plt.subplot(3, 1, 2) plt.plot(x, beacon_error[1], '-', x, kalman_error[1], '-', x, odometry_error[1], '-', linewidth=2) plt.ylabel('Y-coordinate') # Plot the angle errors plt.subplot(3, 1, 3) l1, l2, l3 = plt.plot(x, beacon_error[2], '-', x, kalman_error[2], '-', x, odometry_error[2], '-', linewidth=2) plt.xlabel('number of elements') plt.ylabel('Angle (degrees)') plt.figlegend((l1, l2, l3), ('sensor', 'kalman filter', 'odometry')) # Show the plot to the user plt.show() # Pause the simulation self._paused = True if event.key == pygame.K_LEFT: self.robot.vel_left += self.velocity_base if event.key == pygame.K_RIGHT: self.robot.vel_left -= self.velocity_base if event.key == pygame.K_UP: self.robot.vel_right += self.velocity_base if event.key == pygame.K_DOWN: self.robot.vel_right -= self.velocity_base if self.robot.vel_left > self.velocity_max: self.robot.vel_left = self.velocity_max if self.robot.vel_right > self.velocity_max: self.robot.vel_right = self.velocity_max if self.robot.vel_left < self.velocity_min: self.robot.vel_left = self.velocity_min if self.robot.vel_right < self.velocity_min: self.robot.vel_right = self.velocity_min
def plot( datasets, var_names, est_method=WidthEstimationMethod.MASS_WEIGHTED, figwidth=7.0, figlegend=None, line_colors="default", cumulant_scale_plot_lim=None, ): z = datasets[0].zt v1, v2 = var_names figheight = figwidth / 7.0 * 2.6 fig, axes = plt.subplots( ncols=len(datasets) * 2, nrows=len(z), figsize=(figwidth * len(datasets), figheight * len(z)), ) if line_colors == "default": line_colors = sns.color_palette(n_colors=len(datasets)) else: assert len(line_colors) == len(datasets) loc_x = plticker.MultipleLocator(base=200) def sp(ds_, ax1, ax2, line_color, add_width_label_legend=False): cumulant_analysis.covariance_plot(ds_[v1], ds_[v2], log_scale=False, ax=ax1, line_color=line_color) ax1.set_title("") width_indicator = "floating_legend" if add_width_label_legend else "no_label" cumulant_analysis.covariance_direction_plot( ds_[v1], ds_[v2], ax=ax2, width_est_method=est_method, line_color=line_color, width_indicator=width_indicator, ) ax2.set_title("") ax2.ticklabel_format(style="sci", axis="y", scilimits=(0, 0)) ax2.get_legend().remove() ax2.xaxis.set_minor_locator(loc_x) ax2.axhline(0.0, linestyle="--", color="grey") ax2.grid(which="minor", axis="both", linestyle="--") if cumulant_scale_plot_lim is not None: ax2.set_xlim(cumulant_scale_plot_lim) ax1.set_xlim(2.5 * np.array(cumulant_scale_plot_lim) / 1.0e3) ax1.set_ylim(2.5 * np.array(cumulant_scale_plot_lim) / 1.0e3) # plot in order of decreasing height for n, z_ in enumerate(tqdm(z[::-1])): for n_d in range(len(datasets)): ds_ = datasets[n_d].sel(zt=z_).squeeze().rename( dict(xt="x", yt="y")) if n + 1 == len(z) and n_d + 1 == len(datasets): add_width_label_legend = True else: add_width_label_legend = False sp( ds_, axes[n, n_d * 2], axes[n, n_d * 2 + 1], line_color=line_colors[n_d], add_width_label_legend=add_width_label_legend, ) # using fig.text instead of ax.text avoids matplotlib trying to scale # the subplot to fit the text fig.text(-0.6, 1.1, "z={}m".format(z_.values), transform=axes[n, 0].transAxes) for n_d in range(len(datasets)): ax = axes[0, n_d * 2] fig.text( 1.7, 1.4, datasets[n_d].name, transform=ax.transAxes, horizontalalignment="center", ) fig.tight_layout() handles, labels = axes[0, 1].get_legend_handles_labels() labels = [label.split("=")[0].strip() + "$" for label in labels] labels = [ f"{label}: principle dir." if r"{p}" in label else f"{label}: perpendicular dir." for label in labels ] if figlegend is True: plt.figlegend( handles, labels, loc="upper right", bbox_to_anchor=(1.0, 0.0), ncol=2, ) return fig, axes
def main(): parser = argparse.ArgumentParser() parser.add_argument("-c", "--configuration", required=True, type=argparse.FileType("r")) parser.add_argument("--title", required=False, default="") parser.add_argument("--log", action="store_true", default=False) parser.add_argument( "--out", required=False, default=None, help= "Output file. If unspecified, the script will exit after printing the numbers." ) parser.add_argument( "--genes", default=False, action="store_true", help= "Flag. If switched on, the gene level will be used instead of the transcript level." ) parser.add_argument("-p", "--procs", default=multiprocessing.cpu_count(), type=int) parser.add_argument("--transcripts", action="store_true", default=False) parser.add_argument("--division", action="store_true", default=False) # parser.add_argument("refmap", nargs=10, type=argparse.FileType("rt")) args = parser.parse_args() data = OrderedDict() options = parse_configuration(args.configuration) if options["colourmap"]["use"] is True: color_normalizer = matplotlib.colors.Normalize(0, len(options["methods"])) color_map = cm.get_cmap(options["colourmap"]["name"]) header = ["Method", "Division", "Fully", "Missed", "Fused"] print(*header, sep="\t") pool = multiprocessing.Pool(processes=args.procs) for label in options["methods"]: for aligner in options["divisions"]: if options["methods"][label][aligner] is not None: data[(label, aligner)] = [set(), set(), set()] orig_refmap = "{}.refmap".format( re.sub(".stats$", "", options["methods"][label][aligner][0])) with open(orig_refmap) as refmap: for row in csv.DictReader(refmap, delimiter="\t"): if args.genes is True: if row["best_ccode"] in ("=", "_"): data[(label, aligner)][0].add(row["ref_gene"]) elif row["best_ccode"][0] == "f": data[(label, aligner)][2].add(row["ref_gene"]) # elif row["best_ccode"] in ("NA", "p", "P", "i", "I", "ri", "rI", "X", "x"): # data[(label, aligner)][1].add(row["ref_gene"]) else: if row["ccode"] in ("=", "_"): data[(label, aligner)][0].add(row["ref_id"]) elif row["ccode"][0] == "f": data[(label, aligner)][2].add(row["ref_id"]) filtered_refmap = "{}.refmap".format( re.sub(".stats$", "", options["methods"][label][aligner][1])) with open(filtered_refmap) as refmap: for row in csv.DictReader(refmap, delimiter="\t"): if args.genes is True: if row["best_ccode"] in ("NA", "p", "P", "i", "I", "ri", "rI", "X", "x"): data[(label, aligner)][1].add(row["ref_gene"]) else: if row["ccode"] in ("NA", "p", "P", "i", "I", "ri", "rI", "X", "x"): data[(label, aligner)][1].add(row["ref_id"]) for num in range(3): data[(label, aligner)][num] = len(data[(label, aligner)][num]) orig_stats, filtered_stats = options["methods"][label][ aligner][:2] else: orig_stats, filtered_stats = None, None data[(label, aligner)] = pool.apply_async( parse_refmaps, (orig_stats, filtered_stats, args.transcripts)) for label in options["methods"]: for aligner in options["divisions"]: data[(label, aligner)] = data[(label, aligner)].get() print(label, aligner, *data[(label, aligner)], sep="\t") # print(*data.items(), sep="\n") # Now print out the table if args.out is None: sys.exit(0) # divisions = sorted(options["divisions"].keys()) if args.division is True: figsize = (14, 12) else: figsize = (6, 8) figure, axes = plt.subplots(nrows=1, ncols=3, dpi=300, figsize=figsize) figure.suptitle(args.title) handles = [] labels = [] factor = 10 for pos, ax in enumerate(axes): ax.set_ylim(0, 2) max_x = max(data[_][pos] for _ in data) + 500 min_x = max(0, min(data[_][pos] for _ in data if data[_][pos] > 0) - 500) ax.set_ylim(min_x, max_x) if args.division is False: ax.set_xlim(0, 2.5) else: ax.set_xlim(-2, len(options["divisions"]) * factor) # ax.plot((1, max_x), (1, 1), 'k-') ax.tick_params(axis='both', which='major', labelsize=10) # ax.set_xticklabels([newticks[pos]], fontsize=15) ax.spines["top"].set_visible(False) ax.spines["right"].set_visible(False) ax.spines["left"].set_visible(True) ax.spines["bottom"].set_visible(True) ax.tick_params(axis="y", left="on", right="off") if args.division is False: ax.tick_params(axis="x", top="off", bottom="off") else: ax.tick_params(axis="x", top="off", bottom="on") if pos == 0: if args.transcripts is True: ax.set_ylabel("Number of transcripts", fontsize=16) else: ax.set_ylabel("Number of genes", fontsize=16) ax.set_xlabel("Reconstructed\ngenes", fontsize=16) elif pos == 1: ax.set_xlabel("Missed\ngenes", fontsize=16) else: ax.set_xlabel("Fused\ngenes", fontsize=16) if args.division is True: ax.set_xticks([ factor * (_ + 1 / 4) for _ in range(len(options["divisions"])) ]) ax.set_xticklabels(options["divisions"], rotation=45, fontsize=14) if args.division is False: points = [] else: points = defaultdict(list) for index, tup in enumerate(data.keys()): method, division = tup if options["colourmap"]["use"] is False: colour = options["methods"][method]["colour"] matched = re.match("\(([0-9]*), ([0-9]*), ([0-9]*)\)$", colour) if matched: colour = "#{0:02x}{1:02x}{2:02x}".format( clamp(int(matched.groups()[0])), clamp(int(matched.groups()[1])), clamp(int(matched.groups()[2]))) elif options["methods"][method]["colour"] in ("black", "k"): colour = "black" else: colour = color_map( color_normalizer(options["methods"][division]["index"])) marker = options["divisions"][division]["marker"] cat = "{} ({})".format(method, division) labels.append(cat) point = data[tup][pos] if args.division is False: points.append([point, cat, colour, marker]) else: points[division].append([point, cat, colour, marker]) if args.division is False: points = sorted(points, key=itemgetter(0)) for index, point in enumerate(points): point, cat, colour, marker = point x_coord = 0.5 + (index % 4 / 2) handle = axes[pos].scatter(x_coord, point, alpha=1, label=cat, color=colour, marker=marker, edgecolor="k", s=150) handle.get_sketch_params() if pos == 0: handles.append(handle) handle = mlines.Line2D([], [], markersize=5, color=colour, marker=marker, label=cat, alpha=0.6) else: max_last_xcoord = None for dindex, division in enumerate(options["divisions"].keys()): max_xcoord = -100 min_xcoord = 100000 dpoints = sorted(points[division], key=itemgetter(0)) for index, point in enumerate(dpoints): point, cat, colour, marker = point if index % 3 == 0: x_coord = factor * dindex elif index % 3 == 2: x_coord = factor * (dindex + 1 / 2) else: x_coord = factor * (dindex + 1 / 4) max_xcoord = max(x_coord, max_xcoord) min_xcoord = min(x_coord, min_xcoord) # print(x_coord, point, cat) handle = axes[pos].scatter(x_coord, point, alpha=1, label=cat, color=colour, marker=marker, edgecolor="k", s=150) handle.get_sketch_params() if pos == 0: handles.append(handle) handle = mlines.Line2D([], [], markersize=5, color=colour, marker=marker, label=cat, alpha=0.6) if max_last_xcoord is not None and min_xcoord < max_last_xcoord: raise ValueError("Overlapping X values") max_last_xcoord = max_xcoord # Set the axis to log if necessary if args.log is True: plt.xscale("log") # # plot.plot((1, max(max(data[_]) + 1000 for _ in data)), (2, 2), 'k-') # plot.plot((1, max(max(data[_]) + 1000 for _ in data)), (3, 3), 'k-') handles = [] labels = [] for index, tup in enumerate(data.keys()): method, division = tup if options["colourmap"]["use"] is False: colour = options["methods"][method]["colour"] matched = re.match("\(([0-9]*), ([0-9]*), ([0-9]*)\)$", colour) if matched: colour = "#{0:02x}{1:02x}{2:02x}".format( clamp(int(matched.groups()[0])), clamp(int(matched.groups()[1])), clamp(int(matched.groups()[2]))) elif options["methods"][method]["colour"] in ("black", "k"): colour = "black" else: colour = color_map( color_normalizer(options["methods"][division]["index"])) # color = colors[int(index / 2)] marker = options["divisions"][division]["marker"] cat = "{} ({})".format(method, division) labels.append(cat) # handles.append(handle) for pos, point in enumerate(data[tup]): handle = axes[pos].scatter(point, 1, alpha=1, label=cat, color=colour, marker=marker, edgecolor="k", s=150) handle.get_sketch_params() if pos == 0: handles.append(handle) handle = mlines.Line2D([], [], markersize=5, color=colour, marker=marker, label=cat, alpha=0.6) div_labels = [] for division in options["divisions"]: faux_line = mlines.Line2D( [], [], color="white", marker=options["divisions"][division]["marker"], markersize=14, markerfacecolor="black") div_labels.append((faux_line, division)) for method in options["methods"]: if options["colourmap"]["use"] is False: colour = options["methods"][method]["colour"] matched = re.match("\(([0-9]*), ([0-9]*), ([0-9]*)\)$", colour) if matched: colour = "#{0:02x}{1:02x}{2:02x}".format( clamp(int(matched.groups()[0])), clamp(int(matched.groups()[1])), clamp(int(matched.groups()[2]))) elif options["methods"][method]["colour"] in ("black", "k"): colour = "black" else: colour = color_map( color_normalizer(options["methods"][method]["index"])) patch = mpatches.Patch(facecolor=colour, linewidth=1, edgecolor="k") div_labels.append((patch, method)) if args.division is True: fs = 16 else: fs = 10 plt.figlegend(handles=[_[0] for _ in div_labels], labels=[_[1] for _ in div_labels], loc="lower center", scatterpoints=1, ncol=min(ceil(len(options["methods"]) * 2 / 4), 3), fontsize=fs, framealpha=0.5) plt.tight_layout( pad=0.5, h_pad=1, w_pad=1, rect=[ 0.05, # Left 0.15, # Bottom 0.95, # Right 0.95 ]) # Top out = "{}.{}".format(os.path.splitext(args.out)[0], options["format"]) plt.savefig(out, format=options["format"], transparent=True)
def plot_wind_rose(speed, direction, title, label = ""): """ Plot a wind rose for each year :param array speed: wind speed :param array direction : wind direction :param str title: plot title :param str label: optional label """ import matplotlib.pyplot as plt binspeeds=np.array([0.,2.5,5.,7.5,10.,15.,20.,30.,100.]) semi_separation=(2.5/180.)*np.pi # 30 degree bins angles=np.arange(0.0,360.+DEGREEBINS,DEGREEBINS) angles=[((i+(DEGREEBINS/2.))/180.)*np.pi for i in angles] # 2-D histogram (x, y, bins=[xbins,ybins]) good=np.where((direction.mask == False) & (speed.mask == False)) hist2d, xedge, yedge=np.histogram2d(np.deg2rad(direction[good]), speed[good], bins = [angles,binspeeds], normed = True) # normalisation is by bin area => (np.pi/6.)*5 angle*speed plot_angles=[i+semi_separation for i in angles[:-1]] LegendBars=[] LegendLines=[] # YlGnBu from ColorBrewer with 8 steps colours = ['#FFFFD9',\ '#EDF8B1',\ '#C7E9B4',\ '#7FCDBB',\ '#41B6C4',\ '#1D91C0',\ '#225EA8',\ '#0C2C84'] fig=plt.figure(figsize=(8,8.5)) plt.clf() ax=fig.add_axes([0.1,0.15,0.8,0.8], polar=True) for yb,ybins in enumerate(yedge[:-1]): if yb==0: bars=ax.bar(plot_angles,hist2d[:,yb], \ width=(DEGREEBINS/180.)*np.pi-2.*semi_separation, \ bottom=0,color=colours[yb]) else: # left,height, width, bottom bars=ax.bar(plot_angles,hist2d[:,yb], \ width=(DEGREEBINS/180.)*np.pi-2.*semi_separation, \ bottom=np.sum(hist2d[:,0:yb],axis=1),color=colours[yb]) LegendBars+=[bars[0]] if yb != len(yedge[:-1])-1: LegendLines+=["%i-%i" %(binspeeds[yb],binspeeds[yb+1])] else: LegendLines+=[">%i" %(binspeeds[yb])] ax.set_theta_direction(-1) ax.set_theta_zero_location("N") plt.figlegend(LegendBars,LegendLines,loc=8,frameon=False,ncol=4, title="Wind Speed (m/s)") watermarkstring="/".join(os.getcwd().split('/')[4:])+'/'+os.path.basename( __file__ )+" "+dt.datetime.strftime(dt.datetime.now(), "%d-%b-%Y %H:%M") plt.figtext(0.01,0.01,watermarkstring,size=6) plt.figtext(0.7,0.95,title) if label != "": plt.figtext(0.7,0.9, label) plt.show() return
xf = [0] + [pa['Age_group[T.%s]' % a] for a in ages] xm = [0] + [pa['Age_group[T.%s]:Sex[T.Male]' % a] for a in ages] xf = np.asarray(xf) xm = np.asarray(xm) xm += pa['Sex[T.Male]'] # Plot the age and sex effects plt.clf() plt.axes([0.1, 0.1, 0.7, 0.8]) plt.grid(True) plt.plot(an, xf, label="Female") plt.plot(an, xf + xm, label="Male") plt.xlabel("Age") plt.ylabel("Log risk ratio for deaths") ha, lb = plt.gca().get_legend_handles_labels() leg = plt.figlegend(ha, lb, "center right") leg.draw_frame(False) pdf.savefig() # Next we plot the male/female log risk ratio by age group. This # shows how much more likely a male is to die than a female in each # month. This effect holds for all age groups in all years. plt.clf() plt.grid(True) plt.plot(an, xm, label="Male") plt.xlabel("Age") plt.ylabel("Male/female log risk ratio") pdf.savefig() # Next we consider the mortality risk by month for females and males.
rest_xs = xss[test_ix[col]] rest_ys = yss[test_ix[col]] ax.scatter(rest_xs, rest_ys, c='magenta', edgecolors='none', s=marker_size, zorder=10, label='training') ax.set_xlim([0, 250]) ax.set_title('output {} (95%)'.format(col)) h, l = ax.get_legend_handles_labels() plt.figlegend(h, l, loc="upper center", borderaxespad=0., ncol=6) print('fx2007graph.pdf') plt.savefig(outdir + 'fx2007graph.pdf', format='pdf', bbox_inches='tight') plt.clf() print('weather picture') test_fx = ['cam', 'chi'] xss, yss, test_xss, test_yss, cols = weather() kgen, rgen, slfmgen, indepgen = slfm_gp(len(xss), 2) np.random.seed(1234) fk = FunctionalKernel(D=len(xss), lmc_kernels=kgen(), lmc_ranks=rgen(),
def custom_plot(fname, df_, x_key, y_keys, hue="key", hue_keys=None, OUTPUT_DATA=False, disable_legend=True): plt.close('all') print fname if len(df_) == 0: print "No records for this test in this data set" return yid = 1 for y_key in y_keys: # print(df_) # if df_[y_key] == None: # continue print str(yid) + " : " + y_key # Output data if OUTPUT_DATA: for t in [2, 4, 8, 16, 32, 64]: print "Threads: %d" % t df_t = df_ temp = df_t[x_key] == t df_t = df_t[temp] s = "row/col" for k1 in hue_keys: df_k1 = df_t temp = df_k1[hue].str.contains(k1) df_k1 = df_k1[temp] x = df_k1[y_key].mean() s += ", %s(%.2f)" % (k1, x) print s for k1 in ["WaitFree", "Linux"]: df_k1 = df_t temp = df_k1[hue].str.contains(k1) df_k1 = df_k1[temp] x = df_k1[y_key].mean() s = "%s(%.2f)" % (k1, x) for k2 in hue_keys: df_k2 = df_t temp = df_k2[hue].str.contains(k2) df_k2 = df_k2[temp] # print len(df_k2) y = df_k2[y_key].mean() s += ", %.2f" % (100 * (x - y) / y) print s f, ax = plt.subplots(1, 1, figsize=(3.25, 1.75)) ax = sns.barplot(x=x_key, y=y_key, hue=hue, hue_order=hue_keys, data=df_, ax=ax) # title = (y_key.split(":")[3]).title() # ax.set_title(title) # manipulate the y_key string to create a more meaningful y-axis label ylabel = y_key[19:] if ":" not in ylabel: splitted = ylabel.split("_") ylabel = splitted[1] + "ed " + splitted[0].title() + " Operations" elif "fail" in ylabel: ylabel = "Total Failed Operations" elif "pass" in ylabel: ylabel = "Total Passed Operations" else: ylabel = "Total Operations" ax.set_xlabel("Threads") ax.set_ylabel(ylabel) # ax.set(ylim=(0, 3.5 * pow(10, 7))) ax.spines['left'].set_visible(False) ax.spines['right'].set_visible(False) ax.spines['top'].set_visible(False) ax.yaxis.set_ticks_position('left') ax.xaxis.set_ticks_position('bottom') # ax.set_ylabel("Operations") # ax.legend(title = '') # ax.legend(loc = 'best'); # ax.legend(bbox_to_anchor = (1.05, 1), loc = 2, borderaxespad = 0.) # for some reason, the lock free MCAS buffer always had '(2)' at the end in the legend for text in ax.legend(bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.).get_texts(): if '(2)' in text.get_text(): text.set_text(text.get_text().split('(')[0]) yid += 1 directory = os.path.dirname("graphs/") if not os.path.exists(directory): os.mkdir(directory) if not disable_legend: figLegend = plt.figure(figsize=(6.25, .5)) plt.figlegend(*ax.get_legend_handles_labels(), ncol=6, loc='center left') for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] + ax.get_xticklabels() + ax.get_yticklabels()): item.set_fontsize(5) plt.savefig("graphs/" + fname + '_legend.pdf') plt.close() return else: # ax.legend_.remove() pass plt.savefig( "graphs/" + fname + "_" + ("_".join(y_key.split(":"))).title() + ".pdf", bbox_inches='tight') # saves the current figure into a pdf page plt.close()
def fit_model(df): channel = 20 model = HDBSCAN( algorithm='best', #alpha=1.0, approx_min_span_tree=True, gen_min_span_tree=False, leaf_size=50, #memory=Memory(cachedir=None), metric='euclidean', min_cluster_size=4 * 24 * 14, min_samples=4 * 24, #p=None, core_dist_n_jobs=-1, cluster_selection_method="leaf", cluster_selection_epsilon=0.15, ) def model_channel(i): model.fit(df.iloc[:, i:i + 1].values) pred = model.fit_predict(df.iloc[:, i:i + 1].values) test_df = pd.DataFrame() test_df['date_time'] = df.index test_df = test_df.sort_values(by='date_time') test_df['score'] = model.outlier_scores_ test_df.score.fillna(0, inplace=True) test_df['usage'] = df.iloc[:, i:i + 1].values test_df['anomaly'] = pred test_df.loc[test_df.anomaly >= 0, 'anomaly'] = 1 #outliers=test_df.loc[test_df['anomaly'] == -1] #outlier_index=list(outliers.index) channel_id = df.columns[i] test_df['channel_id'] = channel_id test_df['shift'] = test_df['usage'].shift(-1) test_df['percentage_change'] = ( (test_df['usage'] - test_df['shift']) / test_df['usage']) * 100 test_df = test_df.drop('shift', 1) test_df.to_csv(f"~/data/hdbscan_channel_{channel_id}.csv", index=False) return test_df # visualization fig, axes = plt.subplots(3, 3) fig.subplots_adjust(hspace=0.5) fig.suptitle('Outliers by Channel') for ax, i in zip(axes.flatten(), range(18, 27)): test_df = model_channel(i) print(test_df['anomaly'].value_counts()) ax.set(title=f"Channel {i + 1}") #X_train, X_test = train_test_split(test_df, train_size=(2/3), random_state=1234, shuffle=False) a = test_df.loc[test_df['anomaly'] == -1, ['date_time', 'usage']] #anomaly ax.plot(test_df['date_time'], test_df['usage'], color='blue', label='Normal') ax.scatter(a['date_time'], a['usage'], color='red', label='Anomaly') plt.gcf().autofmt_xdate() handles, labels = ax.get_legend_handles_labels() plt.figlegend(handles, labels, bbox_to_anchor=(0.5, 0.5, 0.5, 0.5), loc='center right') plt.show()
ax1.set_xlabel('$k_h$') ax1.set_ylabel('2D spectra') plt.rc('legend', numpoints=1) leg1 = plt.figlegend( [l_Etot[0], l_EK[0], l_EA[0]], ['$E$', '$E_K$', '$E_A$'], loc=(0.78, 0.7), labelspacing = 0.2 ) ax1.set_xlim([0.1,150]) ax1.set_ylim([1e-5,2e1]) create_fig.save_fig() plt.show()
plt.plot(l2_error) plt.xlabel('t') plt.ylabel('RMSE') plt.title('Error plot') plt.show() # PCA pca = decomposition.PCA(n_components=1) pca.fit(data.T) predicted = pca.transform(predicted.T).T target = pca.transform(target.T).T plt.plot(x, predicted[0, :]) plt.plot(x, target[0, :]) plt.xlabel('t') plt.figlegend(['predicted', 'target'], loc='upper left') plt.title('Data plot PCA') plt.show() l2_error = norm(predicted - target, axis=0) / np.mean(norm(target, axis=0)) print(calculate_prediction_horizon(l2_error, 0.3)) plt.plot(l2_error) plt.xlabel('t') plt.ylabel('RMSE') plt.title('Error plot PCA') plt.show() # graph_count = 4 # offset = 0 # for i in range(graph_count): # plt.subplot(graph_count / 2, 2, i + 1)
partialSum = np.sum(omega[:,j,:]*(ratioEa[:,j,:]-multiplicityEa[:,j,:]), axis=1) lgs = [] for i,a in enumerate(range(minAlfa,maxAlfa)): #alfa lgs.append(axarr[maxRanges-1-j].fill_between(co2, partialSum, color=cm(a/(maxAlfa-1)), label=labelAlfa[a])) lastOmegas[maxRanges-1-j,i] = partialSum[-1] partialSum -= omega[:,j,i]*(ratioEa[:,j,i]-multiplicityEa[:,j,i]) epsilon[:,j,i] = omega[:,j,i]*(ratioEa[:,j,i]-multiplicityEa[:,j,i]) myLegends = [] myLabels = []#[r"$E_a$", r"$E^f + \sum_\alpha \;\epsilon_\alpha$"] myLegends += lgs for i in range(maxAlfa-1,minAlfa-1,-1): #alfa myLabels.append(labelAlfa[i]) myLabels.append("Rel. err.") plt.figlegend(myLegends, myLabels, loc=(0.68,0.15), prop={'size':11}) #plt.savefig("multiplicitiesOmegas"+ext+".svg", bbox_inches='tight') if lmbdas: figS, axar = plt.subplots(2, sharex=True, figsize=(5,4)) figS.subplots_adjust(top=0.95,left=0.15, right=0.95) inf.smallerFont(axar[0], 8) inf.smallerFont(axar[1], 8) p.minA = 0; p.maxA = 4; p.maxA = 4 if p.rLib == "farkas": p.minA = 0; p.maxA = 7; p.maxA = 7 labelAlfa[4] = labelAlfa[22] labelAlfa[5] = labelAlfa[23] labelAlfa[6] = labelAlfa[24] tempMavgS, omegaS, totalRateS, totalRateEventsS, ratesS, ratiosS = mi.getMavgAndOmega(p,temperatures,workingPath)
mew=0.5, style=['--o', '-s', '--v', '-^', '--<', '->'], grid=True) ax.set_title('Impact %d' % groupID, y=0.96) ax.set_ylim([-0.07, 1.05]) if groupID % 5 != 0: ax.set_yticklabels([]) else: ax.set_ylabel('Probability') if groupID < 5: ax.set_xlabel('(%s)' % labs[groupID], labelpad=-5) ax.set_xticklabels([]) else: ax.set_xlabel('# baselines\n(%s)' % labs[groupID]) if groupID == 0: ax.axvspan(4, 24, color='grey', alpha=0.2) # ax.set_xticks(np.unique(prob.index.get_level_values(1).values)) # break axarr[0, 0].set_title('Baseline') pyplot.figlegend(ax.lines, np.unique(prob.index.get_level_values(0).values), loc='upper center', ncol=6, labelspacing=0.) pyplot.savefig('experiment_performance.svg') #pyplot.show()
def currdenfig(self, title=None, times=[0], z_index=0, leg_kwargs={}, **kwargs): """Plot current densities of the cell segments at times. **Arguments:** - *title*: Title for the figure - *times*: List of times at which the data should be sampled If multiple times are given, then subfigures will be generated. - *z_index*: z-index at which the current densities are taken - *leg_kwargs*: Dictionary of keyword arguments for :meth:`matplotlib.pyplot.legend` If *leg_kwargs* is *None*, then no legend will be shown. - *\*\*kwargs*: Additional arguments for :meth:`barfig` """ # Process the arguments. xlabel = kwargs.pop('xlabel', 'y-axis index (inlet to outlet)') name_template = self.cell + ('iprimeprime_seg[%i, ' + '%i]' % (z_index + 1)) #description = self.get_description(name_template % 1) #unit = self.get_unit(name_template % 1) unit = self.get_unit(name_template % 1) #ylabel = kwargs.pop('ylabel', label_number(description, unit)) ylabel = kwargs.pop('ylabel', label_number("Current density", unit)) # Create the plot. ax = self.barfig(names=[name_template % (i_y + 1) for i_y in range(1)], times=times, xlabel=xlabel, ylabel=ylabel, leg_kwargs=None, **kwargs) for a, time in zip(ax, times): a.axhline(self.get_values('cell.iprimeprime', time), linestyle='--', color='k', label='Entire cell') # Decorate. if title is None: if self.n_z == 1: plt.title("Current Distribution of Cell Segments") else: plt.title("Current Distribution of Cell Segments\n" "z-axis index %i (of %i)" % (z_index + 1, self.n_z)) if leg_kwargs is not None: loc = leg_kwargs.pop('loc', 'best') if len(ax) == 1: ax[0].legend(loc=loc, **leg_kwargs) else: plt.figlegend(ax[0].lines, **leg_kwargs)
def plotPCA(proj3D, X_r, PCs, ligs, colors, csvPath, fl_saveEPS, fl_savePNG, annotate): """ Plot the PCA data on 2D plot """ # Set some figure parameters plt.rcParams['xtick.major.pad'] = '8' plt.rcParams['ytick.major.pad'] = '8' # Main figure fig = plt.figure(figsize=(13, 12), dpi=100) if proj3D: ax = fig.add_subplot(111, projection="3d") for label, col, x, y, z in zip(ligs, colors, X_r[:, 0], X_r[:, 1], X_r[:, 2]): newCol = makeColor(col) Axes3D.scatter(ax, x, y, z, label=label, c=newCol, marker="o", lw=1, s=800) ax.set_xlabel("PC1 (" + '{0:g}'.format(PCs[0]) + " %)", fontsize=30) ax.set_ylabel("PC2 (" + '{0:g}'.format(PCs[1]) + " %)", fontsize=30) ax.set_zlabel("PC3 (" + '{0:g}'.format(PCs[2]) + " %)", fontsize=30) ax.xaxis.labelpad = 20 ax.yaxis.labelpad = 20 ax.zaxis.labelpad = 20 ax.tick_params(axis="both", which="major", labelsize=20) imgPath = csvPath.replace(".csv", "_3D") else: ax = fig.add_subplot(111) for label, col, x, y in zip(ligs, colors, X_r[:, 0], X_r[:, 1]): newCol = makeColor(col) ax.scatter(x, y, label=label, color=newCol, marker="o", lw=1, s=800) if annotate: ax.annotate(label, xy=(x, y - 0.05), fontsize=30, ha='center', va='bottom') ax.set_xlabel("PC1 (" + '{0:g}'.format(PCs[0]) + " %)", fontsize=30) ax.set_ylabel("PC2 (" + '{0:g}'.format(PCs[1]) + " %)", fontsize=30) ax.tick_params(axis="both", which="major", labelsize=30) imgPath = csvPath.replace(".csv", "_2D") # figTitle = "PCA on " + csvPath + " (PC1=" + pcVals[0] + ", PC2=" + # pcVals[1] + ")" # ax.text(0.5, 1.04, figTitle, horizontalalignment="center", fontsize=30, # transform=ax.transAxes) # Legend figure fig_legend = plt.figure(figsize=(13, 12), dpi=100) plt.figlegend(*ax.get_legend_handles_labels(), scatterpoints=1, loc="center", fancybox=True, shadow=True, prop={"size": 30}) # Save figures if in EPS and/or PNG format if fl_saveEPS: print("\nSAVING figures in EPS format\n") fig.savefig(imgPath + ".eps", bbox_inches="tight", dpi=1200) fig_legend.savefig(imgPath + "_legend.eps", dpi=1200) if fl_savePNG: print("\nSAVING figures in PNG format\n") fig.savefig(imgPath + ".png", bbox_inches="tight", dpi=300) fig_legend.savefig(imgPath + "_legend.png", dpi=300) # Otherwise show the plots if not fl_saveEPS and not fl_savePNG: print("\nSHOWING figures\n") plt.show()
plt.tick_params(labelsize=30) plt.gca().axes.get_yaxis().set_visible(False) ################### # PLOT 4 at t=200 # ################### eta_hom = hom_data_for_python[:,3] eta1_FV = FV_data_for_python[:,5] eta2_FV = FV_data_for_python[:,6] xmax=x_hom[np.argmax(eta_hom)] shift=300 shift_FV=400 plt.subplot(133) line1=plt.plot(x_hom+shift,eta_hom,'-k',linewidth=4)[0] line2=plt.plot(x_FV+shift_FV,eta1_FV,'--b',linewidth=5)[0] line3=plt.plot(x_FV+shift_FV,eta2_FV,'-r',linewidth=4)[0] plt.ylim([0.75-0.0002, 0.7506]) plt.xlim([xmax+shift-DXLeft,xmax+shift+DXRight]) plt.tick_params(labelsize=30) plt.gca().axes.get_yaxis().set_visible(False) plt.figlegend(handles=(line1, line2, line3), labels=('Homogenized linear system', 'Shallow water model at y=0.25', 'Shallow water model at y=-0.25'), loc='upper center', ncol=3, labelspacing=20., fontsize=30) plt.savefig('homog_corr1.png',bbox_inches="tight")
tf = [r['f'] for r in test_rouge_bl] plt.plot(range(num_groups), tf) if (model_type == EXTRACTIVE): lf = [r['f'] for r in label_rouge_bl] plt.plot(range(num_groups), lf) plt.plot(range(num_groups), [lf[g] - tf[g] for g in range(num_groups)]) #Create Directory to store the ROC Curves if it doesn't already exist if not os.path.exists('Plots/DLB_Analysis'): os.makedirs('Plots/DLB_Analysis') #Save ROC Curve print("Saving DLB Analysis...") DLB = {'p': tp, 'r': tr, 'f': tf} json.dump(DLB, open('Plots/DLB_Analysis/' + model_name + '_DLB.json', 'w')) if (model_type == EXTRACTIVE): plt.figlegend(labels=['Model', 'Labels', 'Difference'], loc='lower right') plt.tight_layout() plt.show() if (model_type == EXTRACTIVE): print("Number of Sentences Predicted by Label Analysis") plt.figure(figsize=(8, 6)) plt.subplot(221) plt.title("Precision vs # of Sent Pred by Label") tp = [r['p'] for r in test_rouge_ns] lp = [r['p'] for r in label_rouge_ns] plt.plot(range(1, max_sent + 1), tp) plt.plot(range(1, max_sent + 1), lp) plt.plot(range(1, max_sent + 1), [lp[g] - tp[g] for g in range(max_sent)]) plt.subplot(222)
def plot_bins(fig_path, plot_label, xscale, nbins_x, nbins_y, y_lim, xy_data_frames): def find_max_num_for_plot(bins_y, xy_data_frames, y_lim): max_num = 0 for df in xy_data_frames: for elem in df.y_split: y_bins = numpy.linspace(y_lim[0], y_lim[1], num=nbins_y + 1, endpoint=True) freq, _ = numpy.histogram(elem, bins=y_bins) if max(freq) > max_num: max_num = max(freq) return max_num will_del_index = [] for i in xrange(xy_data_frames[0].num): will_del = False for df in xy_data_frames: if numpy.isnan(df.x[i]): will_del = True if numpy.isnan(df.y[i]): will_del = True will_del_index.append(will_del) for df in xy_data_frames: df.delete_elems_by_index(will_del_index) x_data = [] for df in xy_data_frames: x_data = numpy.concatenate([x_data, df.x]) bins_x = stats.mstats.mquantiles( x_data, numpy.linspace(0.0, 1.0, num=nbins_x + 1, endpoint=True)) freq, _ = numpy.histogram(x_data, bins=bins_x) for df in xy_data_frames: df.ind = numpy.digitize(df.x, bins_x) y_split = [] x_split = [] for i in xrange(1, nbins_x + 1): y_split.append([df.y[j] for j in xrange(df.num) if df.ind[j] == i]) x_split.append([df.x[j] for j in xrange(df.num) if df.ind[j] == i]) df.y_split = y_split df.x_split = x_split max_num = find_max_num_for_plot(nbins_y, xy_data_frames, y_lim) max_num *= 1.1 plot_label = plot_label + ', x_max=' + str(max_num) fig_bin, axes = plt.subplots(nrows=1, ncols=nbins_x, sharey=True, figsize=(24, 6)) x_bin_num = 0 for ax in axes.flat: y_data = [] colors = [] labels = [] for df in xy_data_frames: y_data.append(df.y_split[x_bin_num]) colors.append(df.color) labels.append(df.label) y_bins = numpy.linspace(y_lim[0], y_lim[1], num=nbins_y + 1, endpoint=True) ax.hist(y_data, bins=y_bins, normed=0, histtype='bar', color=colors, label=labels, orientation="horizontal") ax.set_xscale(xscale) ax.set_xlim((0, max_num)) ax.set_ylim(y_lim) ax.get_xaxis().set_ticks([]) ax.set_xlabel("{0:.1f}-{1:.1f}".format(bins_x[x_bin_num], bins_x[x_bin_num + 1])) x_bin_num += 1 fig_bin.suptitle(plot_label, fontsize=14) fig_bin.subplots_adjust(bottom=0.25) patches = [] for df in xy_data_frames: patches.append(mpatches.Patch(color=df.color, label=df.label)) plt.figlegend(handles=patches, labels=labels, loc=(0.1, 0.05)) fig_bin.savefig(fig_path, dpi=100) plt.close(fig_bin)
ax.set_ylim(window_rect[2], window_rect[3]) ax.yaxis.set_major_formatter( ticker.FuncFormatter(lambda y, pos: ('{{:.{:1d}f}}'.format( int(np.maximum(-np.log10(y), 0)))).format(y))) ax.xaxis.set_major_formatter( ticker.FuncFormatter(lambda y, pos: ('{{:.{:1d}f}}'.format( int(np.maximum(-np.log10(y), 0)))).format(y))) handles, labels = ax.get_legend_handles_labels() handles = [handles[0], handles[2], handles[3], handles[4]] labels = [labels[0], labels[2], labels[3], labels[4]] #plt.figlegend(handles=handles, labels=labels, loc="lower center", bbox_to_anchor=(0.25, 0.18)) plt.figlegend(handles=handles, labels=labels, loc="upper center", bbox_to_anchor=(0.7, 0.97), ncol=4, fontsize=10) handles, labels = ax.get_legend_handles_labels() handles = [handles[1], handles[7], handles[5], handles[6]] labels = [labels[1], labels[7], labels[5], labels[6]] #plt.figlegend(handles=handles, labels=labels, loc="lower center", bbox_to_anchor=(0.5, 0.2), ncol=4) plt.figlegend(handles=handles, labels=labels, loc="lower right", bbox_to_anchor=(0.96, 0.38), fontsize=11) plt.tight_layout() plt.show()
def plot_object(self, bands='all', savefig=False, filename='mySN', orientation='horizontal',method='separate', showModel=False,showFit=False,showMicro=False): """Plot the multiply-imaged SN light curves and show/save to a file. Each subplot shows a single-band light curve, for all images of the SN. Parameters ---------- bands : str or list of str 'all' = plot all bands; or provide a list of bands to plot savefig : bool boolean to save or not save plot filename : str if savefig is True, this is the output filename orientation : str 'horizontal' = all subplots are in a single row 'vertical' = all subplots are in a single column method : str Plots the result of separate, series, or color curve method showModel : bool If true, the underlying model before microlensing is plotted as well showFit : bool If true and it exists, the best fit model from self.images['image'].fits.model is plotted showMicro : bool If true and it exists, the simulated microlensing is plotted as well Returns ------- figure : `~matplotlib.pyplot.figure` """ colors=['r','g','b','k','m'] i=0 leg=[] if method=='series': if bands == 'all': bands = set(self.series.table['band']) nbands = len(bands) if orientation.startswith('v'): ncols = 1 nrows = nbands else: ncols = nbands nrows = 1 fig,axlist=plt.subplots(nrows=nrows, ncols=ncols, sharex=True, sharey=False,figsize=(10,10)) if nbands==1: axlist = [axlist] for lc in np.sort([x for x in self.images.keys()]): temp=self.series.table[self.series.table['image']==lc] for b, ax in zip(bands, axlist): if b==list(bands)[0]: leg.append( ax.errorbar(temp['time'][ temp['band']==b], temp['flux'][ temp['band']==b], yerr=temp['fluxerr'][ temp['band']==b], markersize=4, fmt=colors[i]+'.')) else: ax.errorbar(temp['time'][ temp['band']==b], temp['flux'][ temp['band']==b], yerr=temp['fluxerr'][ temp['band']==b], markersize=4, fmt=colors[i]+'.') if showFit: ax.plot(np.arange(np.min(temp['time'][temp['band']==b]),np.max(temp['time'][temp['band']==b]),1), self.series.fits.model.bandflux(b,np.arange(np.min(temp['time'][temp['band']==b]),np.max(temp['time'][temp['band']==b]),1), zp=temp['zp'][temp['band']==b][0], zpsys=temp['zpsys'][temp['band']==b][0]),color='y') ax.text(0.95, 0.95, b.upper(), fontsize='large', transform=ax.transAxes, ha='right', va='top') i+=1 elif method =='color': if bands=='all': if len([x for x in self.color.table.colnames if '-' in x and '_' not in x])!=1: print("Want to plot color curves but need 2 bands specified.") sys.exit(1) else: colname=[x for x in self.color.table.colnames if '-' in x and '_' not in x][0] bands=[colname[:colname.find('-')],colname[colname.find('-')+1:]] elif len(bands) !=2: print("Want to plot color curves but need 2 bands specified.") sys.exit(1) fig=plt.figure(figsize=(10,10)) ax=fig.gca() for lc in np.sort([x for x in self.images.keys()]): temp=self.color.table[self.color.table['image']==lc] ax.errorbar(temp['time'],temp[bands[0]+'-'+bands[1]],yerr=temp[bands[0]+'-'+bands[1]+'_err'], markersize=4, fmt=colors[i]+'.') ax.text(0.95, 0.95, bands[0].upper()+'-'+bands[1].upper(), fontsize='large', transform=ax.transAxes, ha='right', va='top') i+=1 if showFit: mod_time=np.arange(np.min(self.color.table['time']),np.max(self.color.table['time']),1) modCol=self.color.fits.model.color(bands[0],bands[1],self.color.table['zpsys'][0],mod_time) ax.plot(mod_time,modCol,color='y') else: if bands == 'all': bands = self.bands nbands = len(bands) if orientation.startswith('v'): ncols = 1 nrows = nbands else: ncols = nbands nrows = 1 fig,axlist=plt.subplots(nrows=nrows, ncols=ncols, sharex=True, sharey=True,figsize=(10,10)) if nbands==1: axlist = [axlist] microAx={b:False for b in bands} for lc in np.sort([x for x in self.images.keys()]): for b, ax in zip(bands, axlist): if b==list(bands)[0]: leg.append( ax.errorbar(self.images[lc].table['time'][ self.images[lc].table['band']==b], self.images[lc].table['flux'][ self.images[lc].table['band']==b], yerr=self.images[lc].table['fluxerr'][ self.images[lc].table['band']==b], markersize=4, fmt=colors[i]+'.')) if showMicro: ax.set_ylabel('Flux',fontsize='large') else: ax.errorbar(self.images[lc].table['time'][ self.images[lc].table['band']==b], self.images[lc].table['flux'][ self.images[lc].table['band']==b], yerr=self.images[lc].table['fluxerr'][ self.images[lc].table['band']==b], markersize=4, fmt=colors[i]+'.') ax.text(0.95, 0.95, b.upper(), fontsize='large', transform=ax.transAxes, ha='right', va='top') if showFit: time_model = np.arange(self.images[lc].table['time'].min(), self.images[lc].table['time'].max(), 0.1) ax.plot(time_model,self.images[lc].fits.model.bandflux(b,time_model, np.mean(self.images[lc].table['zp'][self.images[lc].table['band']==b]), self.images[lc].zpsys),'k-') if showMicro: time_model=np.arange(self.images[lc].table['time'].min(), self.images[lc].table['time'].max(), 0.1) if microAx[b] is False: ax_divider = make_axes_locatable(ax) ax_ml = ax_divider.append_axes("bottom", size="25%", pad=.4) #ax_ml.set_xlabel('Days (Observer Frame)',fontsize='large') if b==list(bands)[0]: ax_ml.set_ylabel('Microlensing ($\mu$)',fontsize='large') microAx[b]=ax_ml else: ax_ml=microAx[b] ax_ml.plot(time_model,self.images[lc].simMeta['microlensing_params'](time_model/(1+self.images[lc].simMeta['sourcez'])),color=colors[i],linewidth=3) if showModel: # Plot the underlying model, including dust and lensing # effects other than microlesning, as a black curve for # each simulated SN image time_model = np.arange(self.images[lc].table['time'].min(), self.images[lc].table['time'].max(), 0.1) time_shifted = time_model - self.images[lc].simMeta['td'] flux_magnified = self.model.bandflux( b, time_shifted, self.images[lc].table['zp'][self.images[lc].table['band']==b][0], self.images[lc].zpsys) * \ self.images[lc].simMeta['mu'] ax.plot(time_model, flux_magnified, 'k-') i+=1 plt.figlegend(leg,np.sort([x for x in self.images.keys()]), frameon=False, loc='center right', fontsize='medium', numpoints=1) if not showMicro: fig.text(0.02, .5, 'Flux', va='center', rotation='vertical',fontsize='large') fig.text(0.5, 0.02, r'Observer-frame time (days)', ha='center', fontsize='large') plt.suptitle('Multiply-Imaged SN "'+self.object+'"--'+self.telescopename,fontsize=16) if savefig: plt.savefig(filename+'.pdf',format='pdf',overwrite=True) return fig
recover_rate=0.25, infect_rate=infect_rates[i2]) df1 = q3.Euler_Method(model=sis_model, h=h[i1], total_time=total_time, max_steps=max_steps) df2 = q3.Heun_Method(model=sis_model, h=h[i1], total_time=total_time, max_steps=max_steps) q3.draw_subplot(axes[i1, i2], [df1, df2], 'h=%.2f b=%.2f' % (h[i1], infect_rates[i2]), y_max=100) # Make a custom legend for all subplots custom_lines = [ Line2D([0], [0], color=df1.data.line_color, lw=2), Line2D([0], [0], color=df2.data.line_color, lw=2) ] plt.figlegend(custom_lines, [df1.data.method_name, df2.data.method_name], loc='lower center', ncol=3) plt.subplots_adjust(left=0.1, right=0.9, top=0.9, bottom=0.1, wspace=0.4, hspace=0.5) plt.show()
if '--plot' in sys.argv: import matplotlib.pyplot as plt plt.clf() plt.subplot(2, 2, 1) h = plt.plot(states1.t, states1.T, 'g-', states2.t, states2.T, 'b-') # plt.legend(['Reactor 1','Reactor 2'], 2) plt.xlabel('Time (s)') plt.ylabel('Temperature (K)') plt.subplot(2, 2, 2) plt.plot(states1.t, states1.P / 1e5, 'g-', states2.t, states2.P / 1e5, 'b-') # plt.legend(['Reactor 1','Reactor 2'], 2) plt.xlabel('Time (s)') plt.ylabel('Pressure (Bar)') plt.subplot(2, 2, 3) plt.plot(states1.t, states1.V, 'g-', states2.t, states2.V, 'b-') # plt.legend(['Reactor 1','Reactor 2'], 2) plt.xlabel('Time (s)') plt.ylabel('Volume (m$^3$)') plt.figlegend(h, ['Reactor 1', 'Reactor 2'], loc='lower right') plt.tight_layout() plt.show() else: print( """To view a plot of these results, run this script with the option -plot""" )