def write(self): self.writePreHook() for cut in self.contourData.filteredCombinedData: # Add cut to the output filename (outputFilename, ext) = os.path.splitext(self.outputFilename) outputFilename = "{0}_{1}_{2:.0f}{3}".format(outputFilename, cut.key, cut.value, ext) plt.ioff() plt.figure(figsize=(8,6)) #plt.yscale('log') plt.ylim([0,1.0]) plt.figtext(0.05, 0.96, 'Cut: {0} = {1:.0f}'.format(cut.key, cut.value), color='grey', size='small') plt.figtext(0.05, 0.93, 'Plot written at {:%d/%m/%Y %H:%M}'.format(datetime.datetime.now()), color='grey', size='small') for f in self.contourData.contributingRegionsFiltered[cut]: data = self.contourData.filteredData[f][cut] label = filterLabel(f, self.gridConfig) if not cut.isSimple(): plt.xticks( np.arange(len(data)), ["%d_%d" % (x[self.gridConfig.x], x[self.gridConfig.y]) for x in data.values()]) xLabel = "Grid point" else: var = self.gridConfig.x if cut.key == var: var = self.gridConfig.y xLabel = var plt.xticks( np.arange(len(data)), ["%d" % (x[var]) for x in data.values()]) print [x[self.contourData.combineOn] for x in data.values()] plt.plot( [x[self.contourData.combineOn] for x in data.values()], label=label ) plt.plot( [0.05 for x in data.values()], color='r', linestyle='--', linewidth=2)
def makeVenn3(self,truthDict,snr,addon=''): type1 = '.svg' type2 = '.png' f = \ os.path.join(self.destDir,self.fname+'.c'+str(self.ch)+'.snr_'+str(snr)+addon) reqdVennOrder = [('map','not','not'), ('not','map','not'), ('map','map','not'), ('not','not','map'), ('map','not','map'), ('not','map','map'), ('map','map','map')] valSet = list() for vSet in reqdVennOrder: val = truthDict[vSet] valSet.append(val) unmapped = truthDict[('not','not','not')] # Making venn diagram plt.figure(figsize=( 5,5)) v = \ venn3(subsets=valSet,set_labels=('Cycle1:Mock','Cycle2:Mock','Cycle3:Edman')) c = venn3_circles(subsets=valSet,ls='solid') txt = 'unmapped='+str(unmapped)+'\n SNR='+str(snr) plt.title('Peak Mapping :'+self.fname + '.'+self.frame+'\n channel:'+str(self.ch)) plt.figtext( 0.7,0.1,txt) plt.savefig(f+type1,dpi=300) plt.savefig(f+type2,dpi=300) plt.close()
def saveas_pdf(self, pdfname, figsize=(5,2), pos=(0.1,0.1,0.85,0.75), unit='lam', vr=None, brief=False): # import numpy as np if self.__fig__ == None: self.__fig__ = plt.figure(figsize = figsize) else: self.__fig__.set_size_inches(figsize[0], figsize[1]) # ax = self.__fig__.add_axes(pos) # if unit == 'lam': ax.plot(self.lam, self.spec) ax.set_xlabel(r'$\lambda$ ($\mu$m)') ax.set_ylabel(r'Flux (jy)') else: ax.plot(self.v/1e3, self.spec, drawstyle='steps-mid') ax.set_xlabel(r'$V$ (km s$^{-1}$)') ax.set_ylabel(r'Flux (jy)') if vr != None: ax.set_xlim(vr) mx,mn = np.nanmax(self.spec), np.nanmin(self.spec) if (mx-mn) <= mn: ylim = (mn*0.9, mx*1.1) else: ylim = (0, mx*1.1) ax.set_ylim(ylim) # plt.figtext(0.1, 0.87, self.format_info(brief=brief), fontdict={'horizontalalignment': 'left', 'verticalalignment': 'bottom'}) plt.figtext(0.1, 0.60, r'$\int F_\nu d\nu$ = {0:.1e} W m$^{{-2}}$'.format(self.intfluxl), fontdict={'horizontalalignment': 'left', 'verticalalignment': 'bottom'}) plt.savefig(pdfname, bbox_inches='tight') self.__fig__.clf() return
def dovis(self): """ Do runtime visualization. """ plt.clf() phi = self.cc_data.get_var("phi") myg = self.cc_data.grid plt.imshow(np.transpose(phi[myg.ilo:myg.ihi+1, myg.jlo:myg.jhi+1]), interpolation="nearest", origin="lower", extent=[myg.xmin, myg.xmax, myg.ymin, myg.ymax]) plt.xlabel("x") plt.ylabel("y") plt.title("phi") plt.colorbar() plt.figtext(0.05,0.0125, "t = %10.5f" % self.cc_data.t) plt.draw()
def plot_onetimeseries_right(fig,n,ThisOne,xarray,yarray,p): if not p.has_key('ts_ax'): ts_ax = fig.add_axes([p['ts_XAxOrg'],p['YAxOrg'],p['ts_XAxLen'],p['ts_YAxLen']]) ts_ax.hold(False) ts_ax.yaxis.tick_right() TextStr = ThisOne+'('+p['Units']+')' txtXLoc = p['ts_XAxOrg']+0.01 txtYLoc = p['YAxOrg']+p['ts_YAxLen']-0.025 plt.figtext(txtXLoc,txtYLoc,TextStr,color='b',horizontalalignment='left') else: ts_ax = p['ts_ax'].twinx() colour = 'r' if p.has_key('ts_ax'): del p['ts_ax'] ts_ax.plot(xarray,yarray,'r-') ts_ax.xaxis.set_major_locator(p['loc']) ts_ax.xaxis.set_major_formatter(p['fmt']) ts_ax.set_xlim(p['XAxMin'],p['XAxMax']) ts_ax.set_ylim(p['RYAxMin'],p['RYAxMax']) if n==0: ts_ax.set_xlabel('Date',visible=True) else: ts_ax.set_xlabel('',visible=False) TextStr = str(p['nNotM'])+' '+str(p['nMskd']) txtXLoc = p['ts_XAxOrg']+p['ts_XAxLen']-0.01 txtYLoc = p['YAxOrg']+p['ts_YAxLen']-0.025 plt.figtext(txtXLoc,txtYLoc,TextStr,color='r',horizontalalignment='right') if n > 0: plt.setp(ts_ax.get_xticklabels(),visible=False)
def plot_1d(xdata, ydata, color, x_axis, y_axis, system, analysis, average = False, t0 = 0, **kwargs): """ Creates a 1D scatter/line plot: Usage: plot_1d(xdata, ydata, color, x_axis, y_axis, system, analysis, average = [False|True], t0 = 0) Arguments: xdata, ydata: self-explanatory color: color to be used to plot data x_axis, y_axis: strings to be used for the axis label system: descriptor for the system that produced the data analysis: descriptor for the analysis that produced the data average: [False|True]; Default is False; if set to True, the function will calc the average, standard dev, and standard dev of mean of the y-data # THERE IS A BUG IF average=True; must read in yunits for this function to work at the moment. t0: index to begin averaging from; Default is 0 kwargs: xunits, yunits: string with correct math text describing the units for the x/y data x_lim, y_lim: list w/ two elements, setting the limits of the x/y ranges of plot plt_title: string to be added as the plot title draw_line: int value that determines the line style to be drawn; giving myself space to add more line styles if I decide I need them """ # INITIATING THE PLOT... plt.plot(xdata, ydata, '%s' %(color)) # READING IN KWARG DICTIONARY INTO SPECIFIC VARIABLES for name, value in kwargs.items(): if name == 'xunits': x_units = value x_axis = '%s (%s)' %(x_axis, value) elif name == 'yunits': y_units = value y_axis = '%s (%s)' %(y_axis, value) elif name == 'x_lim': plt.xlim(value) elif name == 'y_lim': plt.ylim(value) elif name == 'plt_title': plt.title(r'%s' %(value), size='14') elif name == 'draw_line': draw_line = value if draw_line == 1: plt.plot([0,max(ydata)],[0,max(ydata)],'r-',linewidth=2) else: print 'draw_line = %s has not been defined in plotting_functions script' %(line_value) plt.grid(b=True, which='major', axis='both', color='#808080', linestyle='--') plt.xlabel(r'%s' %(x_axis), size=12) plt.ylabel(r'%s' %(y_axis), size=12) # CALCULATING THE AVERAGE/SD/SDOM OF THE Y-DATA if average != False: avg = np.sum(ydata[t0:])/len(ydata[t0:]) SD = stdev(ydata[t0:]) SDOM = SD/sqrt(len(ydata[t0:])) plt.axhline(avg, xmin=0.0, xmax=1.0, c='r') plt.figtext(0.680, 0.780, '%s\n%6.4f $\\pm$ %6.4f %s \nSD = %4.3f %s' %(analysis, avg, SDOM, y_units, SD, y_units), bbox=dict(boxstyle='square', ec='r', fc='w'), fontsize=12) plt.savefig('%s.%s.plot1d.png' %(system,analysis),dpi=300) plt.close()
def plotta(name,fname,texts,x,y): print name #find optical parameters a,b,pa = galaxy.FULLMAJAX[0],galaxy.FULLMINAX[0], galaxy.PA[0] ra,dec = galaxy.GRA2000[0], galaxy.GDEC2000[0] #pa = pa + 90. beam = 18.2/3600.0 rDust = galaxy.R250[0]*1.4 #make plot f = ap.FITSFigure(fname,figure=fig,subplot=[x,y,dx,dy]) #f.show_contour(str(name)+"-PSWmap-ellipses.fits",levels=[rDust], smooth=1, colors='black') f.recenter(ra,dec,beam*4.) f.show_colorscale(vmin=-6.02e-02, vmax=20.664e-02, cmap='gist_earth') #f.show_contour(fname,levels=150, filled=True, cmap='cool') f.add_scalebar(0.5/60.0) f.scalebar.set_label('30 arcsec') f.scalebar.set_color('black') #f.show_grid() f.set_tick_labels_format(xformat='hh:mm:ss',yformat='dd:mm:ss') #f.show_markers(ra, dec,c='r',marker='x') f.show_ellipses(ra, dec, a*1.15/60.0, a*1.15/60.0, angle=pa, edgecolor='red', lw=1) f.show_ellipses(ra, dec, rDust/60.0, rDust/60.0, angle=pa, edgecolor='black', lw=1) f.add_beam(major=beam, minor=beam,angle=0.0) f.show_beam(major=beam, minor=beam,angle=0.0,fc='white') f.axis_labels.set_font(size=8) f.tick_labels.set_font(size=6) #f.set_theme('publication') # add text plt.figtext(x+tune, y+0.23,texts, size=12, weight="semibold", color='black')
def MOorderplot(popul,path,picname=None,title=None): x=[]; y1=[]; y2=[]; y3=[]; y4=[]; y5=[]; y6=[]; c=[] for i,dude in enumerate(popul): x.append(i) y1.append(dude.no) y2.append(dude.oldno) y3.append(dude.ranks[0]) y4.append(dude.ranks[1]) y5.append(dude.score) y6.append(dude.overall_rank) c.append(dude.score) f=plt.figure(figsize=(8,12)); a1=f.add_subplot(321); a2=f.add_subplot(322); a3=f.add_subplot(323); a4=f.add_subplot(324); a5=f.add_subplot(325); a6=f.add_subplot(326) a1.scatter(x,y1,c=c,cmap=cm.gist_stern) a2.scatter(x,y2,c=c,cmap=cm.gist_stern) a3.scatter(x,y3,c=c,cmap=cm.gist_stern) a4.scatter(x,y4,c=c,cmap=cm.gist_stern) a5.scatter(x,y5,c=c,cmap=cm.gist_stern) a6.scatter(x,y6,c=c,cmap=cm.gist_stern) a1.set_xlabel('place in population'); a1.set_ylabel('dude.no') a2.set_xlabel('place in population'); a2.set_ylabel('dude.oldno') a3.set_xlabel('place in population'); a3.set_ylabel('dude.ranks[0]') a4.set_xlabel('place in population'); a4.set_ylabel('dude.ranks[1]') a5.set_xlabel('place in population'); a5.set_ylabel('dude.score') a6.set_xlabel('place in population'); a6.set_ylabel('dude.overall_rank') if title is not None: plt.figtext(0.5, 0.98,title,va='top',ha='center', color='black', weight='bold', size='large') if picname is not None: plt.savefig(join(path,picname)) else: plt.savefig(join(path,'orderplot_c'+str(popul.ncase)+'_sc'+str(popul.subcase).zfill(3)+'_g'+str(popul.gg)+'.png')) plt.close()
def plot_results(algo, datas, xlabel, ylabel, note, factor=None): plt.clf() fig1, ax1 = plt.subplots() plt.figtext(0.90, 0.94, "Note: " + note, va='top', ha='right') w, h = fig1.get_size_inches() fig1.set_size_inches(w*1.5, h) ax1.set_xscale('log') ax1.get_xaxis().set_major_formatter(ticker.ScalarFormatter()) ax1.get_xaxis().set_minor_locator(ticker.NullLocator()) ax1.set_xticks(datas[0][:,0]) ax1.grid(color="lightgrey", linestyle="--", linewidth=1, alpha=0.5) if factor: ax1.set_xticklabels([str(int(x)) for x in datas[0][:,0]/factor]) plt.xlabel(xlabel, fontsize=16) plt.ylabel(ylabel, fontsize=16) plt.xlim(datas[0][0,0]*.9, datas[0][-1,0]*1.1) plt.suptitle("%s Performance" % (algo), fontsize=28) for backend, data in zip(backends, datas): N = data[:, 0] plt.plot(N, data[:, 1], 'o-', linewidth=2, markersize=5, label=backend) dy = max(data[:,1]) / 20.0 for x, y in zip(N, data[:, 1]): plt.annotate('%.1f' % y, (x, y+dy)) plt.legend(loc='upper left', fontsize=18) plt.savefig(algo + '.png')
def plot_radar(gene2plot, tissue, path): ''' Plot radar plot :param data: :param path: :return: ''' data = gene2plot #[0.00364299,0.0582878,0.04189435,0.13661202,0.10928962,0.14754098,0.00728597,0.0582878,0.40801457,0.3] spoke_labels = tissue #['lung', 'bone', 'blood', 'epithelial', 'progenitor', 'nervous', 'endocrine', 'epidermal', 'immune','liver'] N = len(data) theta = radar_factory(N, frame='polygon') plt.rcParams['font.size'] = 10 fig = plt.figure(figsize=(6, 6)) fig.subplots_adjust(wspace=0.25, hspace=0.20, top=0.85, bottom=0.05) ax = fig.add_subplot(1, 1, 1, projection='radar') #plt.rgrids([0.1, 0.2, 0.3, 0.4]) #ax.set_title('Fraction of gene', weight='bold', fontsize=15, position=(0.5, 1.1), # horizontalalignment='center', verticalalignment='center') ax.plot(theta, data, color='r', lw=1) ax.fill(theta, data, facecolor='r', alpha=0.25) ax.set_varlabels(spoke_labels) plt.figtext(0.5, 0.965, 'Gene enrichment fraction for (tissue)* types', ha='center', color='black', weight='bold', fontsize=15) plt.savefig(os.path.join(path, 'GCAM_redar.svg')) plt.clf() plt.close()
def plot_multiline_alpha(data_list, legend_list, picture_title, picture_save_path, text1, text2): """ Draw data series info """ # plot file and save picture fig = plt.figure(figsize=(15, 8)) left = 0.1 bottom = 0.3 width = 0.75 height = 0.60 ax = fig.add_axes([left, bottom, width, height]) ax.set_title(picture_title) plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%Y')) plt.gca().xaxis.set_major_locator(mdates.YearLocator()) plt.figtext(0.01, 0.01, text1, horizontalalignment='left') plt.figtext(0.51, 0.01, text2, horizontalalignment='left') date_series = data_list[0].index color_list = ['r-', 'b-', 'y-', 'g-'] for i, data_series in enumerate(data_list): plt.plot(date_series, data_series, color_list[i], label=legend_list[i]) min_date = date_series[0] max_date = date_series[-1] plt.gca().set_xlim(min_date, max_date) plt.legend(loc=0) fig.autofmt_xdate() fig.savefig(picture_save_path) plt.close()
def plotEvolution(self, var, name, name_long="new plot", figlabel="Resolution", ylabel="", loc="", reference=False): """ Plots evolution in time of the given variable. """ plt.clf() var = np.array(var) if var.ndim == 1: # in case a single set of data is provided var = [var] ls = ["-.", "--", "-"] kwargs = {} if "bw" in self.file_name: kwargs["color"] = "k" for i in range(len(self.t)): plt.plot(self.t[i], var[i], label="{0} {1}".format(figlabel, i + 1), ls=ls[i], **kwargs) plt.title(self.title.format(name_long)) plt.xlabel(self.xlabel) plt.ylabel(ylabel) if self.info: plt.figtext(self.text_pos[0], self.text_pos[1], self.info) plt.xlim(np.round(np.min(self.t[0])), np.round(np.max(self.t[0]))) if reference: self.plotReference() plt.legend(loc=loc or self.loc) for e in self.ext: plt.savefig(os.path.join(self.out_dir, self.file_name.format(name=name, ext=e)))
def save_fig(self, poly=None, directory="/tmp/plots", overwrite=False, labels=None, extension=".png"): """Save the pass as a figure. Filename is automatically generated. """ logger.debug("Save fig " + str(self)) rise = self.risetime.strftime("%Y%m%d%H%M%S") fall = self.falltime.strftime("%Y%m%d%H%M%S") filename = os.path.join(directory, (rise + self.satellite.replace(" ", "_") + fall + extension)) self.fig = filename if not overwrite and os.path.exists(filename): return filename import matplotlib as mpl mpl.use('Agg') import matplotlib.pyplot as plt plt.clf() with Mapper() as mapper: mapper.nightshade(self.uptime, alpha=0.2) self.draw(mapper, "-r") if poly is not None: poly.draw(mapper, "-b") plt.title(str(self)) for label in labels or []: plt.figtext(*label[0], **label[1]) plt.savefig(filename) return filename
def plot_tiegcm(time, lat, lon, den, temp, ht, pres, image_name): """Plot density, temperature, and geopotential height for all latitudes and longitudes at relevant time""" y_values = [-90, -45, 0, 45, 90] x_values = [-180, -135, -90, -45, 0, 45, 90, 135, 180] fig = plt.figure() # fig.subplots_adjust(left = 0.25, right = 0.7, bottom = 0.07, top = 0.9, wspace = 0.2, hspace = 0.08) sub_den = fig.add_subplot(3, 1, 1) plot_settings(sub_den, den*1e12, lon, lat, y_values, x_values = [], ylabel = "", xlabel = "", title = 'Density', ctitle = r"x 10$^{-12}$ kgm$^{-3}$ ", minmax = [2., 4.]) pres = format(pres, '.2e') plt.title('{} at {} Pa'.format(time, pres), fontsize = 11) sub_temp = fig.add_subplot(3, 1, 2) plot_settings(sub_temp, temp, lon, lat, y_values, x_values = [], ylabel = 'Latitude [$^\circ$]', xlabel = "", title = 'Temperature', ctitle = "Kelvin", minmax = [750., 1250.]) sub_ht = fig.add_subplot(3, 1, 3) plot_settings(sub_ht, ht/100000., lon, lat, y_values, x_values, ylabel = " ", xlabel = 'Longitude [$^\circ$]', title = 'Geopotential Height', ctitle = "km", minmax = [350., 450.]) plt.figtext(.6, .032, r'$\copyright$ Crown Copyright. Source: Met Office', size = 8) plt.tight_layout() # insert_logo() save_to_web(fig, time, image_name)
def _show_3d_plot(self): ''' Shows the plot using pylab. Usually I won't do imports in methods, but since plotting is a fairly expensive library to load and not all machines have matplotlib installed, I have done it this way. ''' import matplotlib.pyplot as plt import mpl_toolkits.mplot3d.axes3d as p3 from matplotlib.font_manager import FontProperties fig = plt.figure() ax = p3.Axes3D(fig) font = FontProperties() font.set_weight('bold') font.set_size(20) (lines, labels, unstable) = self.pd_plot_data count = 1 newlabels = list() for x, y, z in lines: ax.plot(x, y, z, 'bo-', linewidth=3, markeredgecolor='b', markerfacecolor='r', markersize=10) for coords in sorted(labels.keys()): entry = labels[coords] label = entry.name if len(entry.composition.elements) == 1: # commented out options are only for matplotlib 1.0. Removed them so that most ppl can use this class. ax.text(coords[0], coords[1], coords[2], label)#, horizontalalignment=halign, verticalalignment=valign, fontproperties=font) else: ax.text(coords[0], coords[1], coords[2], str(count))#, horizontalalignment=halign, verticalalignment=valign, fontproperties=font) newlabels.append(str(count) + " : " + label) count += 1 plt.figtext(0.01, 0.01, '\n'.join(newlabels)) ax.axis('off') plt.show()
def beaut(fig, axes): for row_i, axes_row in enumerate(axes): for col_i, ax in enumerate(axes_row): ax.set_xticks([]) ax.set_yticks([]) if col_i == 0: ax.set_ylabel(str(row_i)) if row_i == 9: ax.set_xlabel(str(col_i)) plt.figtext( 0.5, 0, "public goods effect threshold", figure=fig, fontsize=17, horizontalalignment='center', verticalalignment='top', ) plt.figtext( 0, 0.5, "quorum sensing threshold", figure=fig, fontsize=17, horizontalalignment='right', verticalalignment='center', rotation=90, ) fig.tight_layout()
def plot_noisy_means(graph_title, means, bands, series, xvals=None, xlabel=None, ylabel=None, subtitle=None, data=None, filename='results.pdf'): colors = ['blue','red','green', 'black', 'orange', 'purple', 'brown', 'yellow'] # max 8 lines assert(means.shape == bands.shape) assert(xvals is None or xvals.shape[0] == means.shape[1]) assert(means.shape[0] <= len(colors)) if xvals is None: xvals = np.arange(means.shape[0]) ax = plt.axes([.1,.1,.8,.7]) plt.ticklabel_format(axis='y', style='plain', useOffset=False) for i,mean in enumerate(means): plt.plot(xvals, mean, label=series[i], color=colors[i]) plt.fill_between(xvals, mean + bands[i], mean - bands[i], facecolor=colors[i], alpha=0.2) if xlabel is not None: plt.xlabel(xlabel) if ylabel is not None: plt.ylabel(ylabel) if subtitle is not None: plt.figtext(.40,.9, graph_title, fontsize=18, ha='center') plt.figtext(.40,.85, subtitle, fontsize=10, ha='center') else: plt.title('{0}'.format(graph_title)) # Shink current axis by 20% box = ax.get_position() ax.set_position([box.x0, box.y0, box.width * 0.8, box.height]) # Put a legend to the right of the current axis ax.legend(loc='center left', bbox_to_anchor=(1, 0.5), fontsize=12) plt.savefig(filename) plt.clf()
def finish_plot(ylabel=r'z [$\mu$ m]'): plt.xlabel(r'$\theta$ [deg]') plt.xlim(0, 360) plt.ylabel(ylabel) yoke_label = ord('A') for i in xrange(0, 37): x = (i * 10.0 - 15.0 - 0.1012) % 360.0 if i % 3 == 0: plt.axvline(x, linestyle='-', color='k', alpha=0.2) else: plt.axvline(x, linestyle='--', color='k', alpha=0.2) if i is not 0: if i < 10: s = str(i) + ' ' else: s = str(i) plt.figtext(0.052 + i * (0.868 / 36.0), 0.86, s, color='k', alpha=0.4) if (i % 3) == 1: plt.figtext(0.052 + i * (0.868 / 36.0), 0.82, chr(yoke_label), color='k', alpha=0.4) yoke_label += 1 plt.show()
def _get_3d_plot(self, label_stable=True): """ Shows the plot using pylab. Usually I won"t do imports in methods, but since plotting is a fairly expensive library to load and not all machines have matplotlib installed, I have done it this way. """ import matplotlib.pyplot as plt import mpl_toolkits.mplot3d.axes3d as p3 from matplotlib.font_manager import FontProperties fig = plt.figure() ax = p3.Axes3D(fig) font = FontProperties() font.set_weight("bold") font.set_size(20) (lines, labels, unstable) = self.pd_plot_data count = 1 newlabels = list() for x, y, z in lines: ax.plot(x, y, z, "bo-", linewidth=3, markeredgecolor="b", markerfacecolor="r", markersize=10) for coords in sorted(labels.keys()): entry = labels[coords] label = entry.name if label_stable: if len(entry.composition.elements) == 1: ax.text(coords[0], coords[1], coords[2], label) else: ax.text(coords[0], coords[1], coords[2], str(count)) newlabels.append("{} : {}".format(count, latexify(label))) count += 1 plt.figtext(0.01, 0.01, "\n".join(newlabels)) ax.axis("off") return plt
def __init__(self): plt.ion() self.fig = plt.figure(num=3, figsize=(12,7)) self.ax = self.fig.gca(projection='3d') self.ax.set_xlim(-255, 255) self.ax.set_ylim(-255, 255) self.ax.set_zlim(-255, 255) axisline = np.linspace(-255, 255, 6) zeros = np.zeros((1,6)).tolist()[0] self.ax.plot(axisline, zeros, zeros, 'b', linewidth=2) self.ax.plot(zeros, axisline, zeros, 'b', linewidth=2) self.ax.plot(zeros, zeros, axisline, 'b', linewidth=2) bbox_props = dict(boxstyle="round", fc="w", ec="0.5", alpha=0.9) self.annotation = plt.figtext(0.02, 0.9, 'rssi = ', size=15, alpha = 0.9, bbox = bbox_props) self.Freq = plt.figtext(0.91, 0.85, 'freq = ???', size=10, alpha = 0.9, bbox = bbox_props) self.Freq = plt.figtext(0.91, 0.9, 'Horizontal Plane', size=10, alpha = 0.9, bbox = bbox_props) # quiver lines (there is no quiver 3d so I draw the vector manually # using plot of two points (0 to rho) self.referencedir = np.array([1, 0, 0]) self.polarline, = self.ax.plot([0, self.referencedir[0]] , [0, self.referencedir[1]], [0, self.referencedir[2]], 'k', linewidth=2) # since its a T shaped, these are the two smaller lines self.wing1 = np.array([0, 1, 0]) self.wing2 = np.array([0, -1, 0]) self.polarline, = self.ax.plot([0, self.wing1[0]] , [0, self.wing1[1]], [0, self.wing1[2]], 'k', linewidth=2) self.polarline, = self.ax.plot([0, self.wing2[0]] , [0, self.wing2[1]], [0, self.wing2[2]], 'k', linewidth=2) # initialize x,y,z buffers for mesh plotting as well self.xdata = [] self.ydata = [] self.zdata = [] self.polarline2, = self.ax.plot(self.xdata,self.ydata, self.zdata, 'r')
def shots4time(player='Noah', team='CHI', s_date='20091001', f_date='20151231', path='D:\Gal\Work\Results'): ''' ''' actions_1, played_games_1 = actions_raster(players=[player], team=team, s_date=s_date, f_date=f_date, path=path, action=c.Shot) actions_2, played_games_2 = time_raster(player, team, s_date, f_date, path) actions_3, played_games_3 = actions_raster(players=[player], team=team, s_date=s_date, f_date=f_date, path=path, action=c.FreeThrow) plt.hold(1) # plt.title(player+','+team) # plt.plot(actions_1, played_games_1, 'b.') # plt.plot(actions_3, played_games_3, 'm.') plt.figure(1) plt.plot(actions_histogram(actions_1), 'b') plt.plot(actions_histogram(actions_2), 'r') plt.plot(actions_histogram(actions_3), 'm') plt.figure(2) plt.title(player+','+team) plt.figtext(0, 0.5, 'blue - shots \n'+'red - presentce on court\n'+'magenta - freethrows') plt.plot(tf.normalize(tf.movingAverage(actions_histogram(actions_1), 3)), 'b') plt.plot(tf.normalize(tf.movingAverage(actions_histogram(actions_2), 3)), 'r') plt.plot(tf.normalize(tf.movingAverage(actions_histogram(actions_3), 3)), 'm') plt.xlabel('Time (in half minutes)') plt.ylabel('Points') plt.grid(axis='x') plt.xticks(np.arange(1, 5)*c.Q_LEN/30) plt.show()
def plot_graph(data_frame, data_frame_features): data_frame_features.remove('irisClass') grouped_data_frame = data_frame.groupby(data_frame['irisClass']).apply( lambda tdf: pd.Series(dict([[vv, tdf[vv].tolist()] for vv in tdf if vv not in ['irisClass']]))) flower_list = set(data_frame['irisClass']) for feature in data_frame_features: data = [] fig, box_plotter = plt.subplots(figsize=(10, 6)) box_plotter.yaxis.grid(True, linestyle='-', which='major', color='lightgrey', alpha=0.5) # Hide these grid behind plot objects box_plotter.set_axisbelow(True) box_plotter.set_xlabel('Distribution of flowers') box_plotter.set_ylabel('Length of features') box_plotter.set_title('Comparison of %s across flowers' % (feature)) for flower in flower_list: data.append(grouped_data_frame[feature][flower]) plt.figtext(0.8, 0.9, '1 --> Iris-Versicolor\n2--> Iris-Virginica\n3--> ' 'Iris-Setosa', backgroundcolor='white', color='black', weight='roman', size='medium') box_plotter.boxplot(data) plt.show()
def i2pcontrol_stats(conn, output=''): things=[ {'stat':'activepeers','xlab':'time','ylab':'total',}, {'stat':'tunnelsparticipating','xlab':'time','ylab':'total',}, {'stat':'decryptFail','xlab':'time','ylab':'total',}, {'stat':'failedLookupRate','xlab':'time','ylab':'total',}, {'stat':'streamtrend','xlab':'time','ylab':'total',}, {'stat':'windowSizeAtCongestion','xlab':'time','ylab':'total',}, #{'stat':'','xlab':'','ylab':'',}, # Template to add more. ] tokens = query_db(conn, 'select owner,token from submitters;') for thing in things: combined=[] dfs=[] for token in tokens: q = 'select datetime(cast(((submitted)/({0})) as int)*{0}, "unixepoch") as sh, {1} from speeds where submitter="{2}" group by sh order by sh desc;'.format(interval, thing['stat'], token[1]) df = pd.read_sql_query(q, conn) # unix -> human df['sh'] = pd.to_datetime(df['sh'], unit='s') dfs.append(df) # Reverse so it's put in left to right combined = reduce(lambda left,right: pd.merge(left,right,on='sh',how='outer'), dfs) combined.columns=['time'] + [i[0] for i in tokens] combined = combined.set_index('time') combined.head(num_intervals).plot(marker='o') plt.figtext(.1,.03,'{}\n{} UTC'.format(site,generation_time)) plt.title(thing['stat']) plt.xlabel(thing['xlab']) plt.ylabel(thing['ylab']) plt.savefig('{}/{}.png'.format(output, thing['stat'])) plt.close()
def pie_graph(conn, query, output, title='', lower=0, log=False): labels = [] sizes = [] res = query_db(conn, query) # Sort so the graph doesn't look like complete shit. res = sorted(res, key=lambda tup: tup[1]) for row in res: if row[1] > lower: labels.append(row[0]) if log: sizes.append(math.log(row[1])) else: sizes.append(row[1]) # Normalize. norm = [float(i)/sum(sizes) for i in sizes] plt.pie(norm, labels=labels, shadow=True, startangle=90, ) plt.figtext(.1,.03,'{}\n{} UTC'.format(site,generation_time)) plt.axis('equal') plt.legend() plt.title(title) plt.savefig(output) plt.close()
def plot_multiline(data_list, legend_list, picture_title, picture_save_path, text=None): """ Draw data series info """ # plot file and save picture fig = plt.figure(figsize=(15, 6)) plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%Y')) plt.gca().xaxis.set_major_locator(mdates.YearLocator()) if text is not None: plt.figtext(0.01, 0.01, text, horizontalalignment='left') date_series = data_list[0].index color_list = ['r-', 'b-', 'y-', 'g-'] for i, data_series in enumerate(data_list): # get data series info plt.plot(date_series, data_series, color_list[i], label=legend_list[i]) min_date = date_series[0] max_date = date_series[-1] plt.gca().set_xlim(min_date, max_date) plt.legend(loc=0) fig.autofmt_xdate() fig.suptitle(picture_title) # print dir(fig) fig.savefig(picture_save_path) plt.close()
def show_spider(p): L = Logging('log') data = L.get_stacked_bar_data('Template', p, 'spider') N = 12 theta = radar_factory(N, frame='polygon') spoke_labels = data.pop('column names') fig = plt.figure(figsize=(7, 7)) fig.subplots_adjust(wspace=0.25, hspace=0.20, top=0.85, bottom=0.05) colors = ['r', 'g', 'b', 'm', 'y'] # Plot the four cases from the example data on separate axes for n, title in enumerate(data.keys()): ax = fig.add_subplot(1, 1, n + 1, projection='radar') # plt.rgrids([0.5, 1.0, 1.5, 2.0, 2.5, 3.0]) ax.set_title(title, weight='bold', size='medium', position=(0.5, 1.1), horizontalalignment='center', verticalalignment='center') for d, color in zip(data[title], colors): ax.plot(theta, d, color=color) ax.fill(theta, d, facecolor=color, alpha=0.25) ax.set_varlabels(spoke_labels) # add legend relative to top-left plot plt.subplot(1, 1, 1) labels = ('Losers', 'Winners') legend = plt.legend(labels, loc=(0.9, .95), labelspacing=0.1) plt.setp(legend.get_texts(), fontsize='small') plt.figtext(0.5, 0.965, 'Winner vs Losers', ha='center', color='black', weight='bold', size='large') plt.show()
def execute(model, data, savepath, *args, **kwargs): descriptors = ['Cu (At%)', 'Ni (At%)', 'Mn (At%)', 'P (At%)', 'Si (At%)', 'C (At%)', 'Temp (C)', 'log(fluence)', 'log(flux)'] xlist = np.asarray(data.get_data(descriptors)) model = model model.fit(data.get_x_data(), np.array(data.get_y_data()).ravel()) error = model.predict(data.get_x_data()) - np.array(data.get_y_data()).ravel() for x in range(len(descriptors)): plt.scatter(xlist[:, x], error, color='black', s=10) xlim = plt.gca().get_xlim() plt.plot(xlim, (20, 20), ls="--", c=".3") plt.plot(xlim, (0, 0), ls="--", c=".3") plt.plot(xlim, (-20, -20), ls="--", c=".3") m, b = np.polyfit(np.reshape(xlist[:, x], len(xlist[:, x])), np.reshape(error, len(error)),1) # line of best fit matplotlib.rcParams.update({'font.size': 15}) plt.plot(xlist[:, x], m * xlist[:, x] + b, color='red') plt.figtext(.15, .83, 'y = ' + "{0:.6f}".format(m) + 'x + ' + "{0:.5f}".format(b), fontsize=14) plt.title('Error vs. {}'.format(descriptors[x])) plt.xlabel(descriptors[x]) plt.ylabel('Predicted - Actual (Mpa)') plt.savefig(savepath.format(plt.gca().get_title()), dpi=200, bbox_inches='tight') plt.close()
def plotta(im,xx,yy,ext): #make plot f = ap.FITSFigure(im,figure=fig,subplot=[xx,yy-dy,dx,dy]) f.show_colorscale(cmap = 'hot', vmin = -1.245E-02, vmax = 2.405E-02 ) f.recenter(ra, dec, re_cen) #if ext == 'E': f.show_ellipses(ra, dec, a/60.0, b/60.0, angle=pa-90, edgecolor='grey', lw=2) #if ext == 'P': #f.show_markers(ra, dec, c='grey',marker='x') #f.add_scalebar(1.0/60.0) f.scalebar.set_label('1 arcmin') #f.scalebar.set_color('white') #f.show_grid() #f.set_tick_labels_format(xformat='hh:mm:ss',yformat='dd:mm:ss') #f.show_markers(ra, dec, c='red',marker='x') #f.add_beam(major=beam, minor=beam,angle=0.0) f.show_beam(major=beam, minor=beam,angle=0.0,fc='white') f.axis_labels.hide() f.tick_labels.hide() # add text plt.figtext(xx+0.012 , yy-dy+0.14, name, size=20, weight="bold", color='white')
def plot_results(datas, factor=None, algo='FFT'): xlabel = r'Array Size (2^x)' ylabel = 'Speed (GFLOPs)' backends = ['numpy', 'numpy+mkl'] plt.clf() fig1, ax1 = plt.subplots() plt.figtext(0.90, 0.94, "Note: higher is better", va='top', ha='right') w, h = fig1.get_size_inches() fig1.set_size_inches(w*1.5, h) ax1.get_xaxis().set_major_formatter(ticker.ScalarFormatter()) ax1.get_xaxis().set_minor_locator(ticker.NullLocator()) ax1.set_xticks(datas[0][:,0]) ax1.grid(color="lightgrey", linestyle="--", linewidth=1, alpha=0.5) if factor: ax1.set_xticklabels([str(int(x)) for x in datas[0][:,0]/factor]) plt.xlabel(xlabel, fontsize=16) plt.ylabel(ylabel, fontsize=16) plt.xlim(datas[0][0,0]*.9, datas[0][-1,0]*1.025) plt.suptitle("%s Performance" % ("FFT"), fontsize=28) for backend, data in zip(backends, datas): N = data[:, 0] plt.plot(N, data[:, 1], 'o-', linewidth=2, markersize=5, label=backend) plt.legend(loc='upper left', fontsize=18) plt.savefig(algo + '.png')
def DBLR_f(self): global a #if (self.graph_sw.get()==True): b=a a=a+1 #else: # b=0 aux=self.base_path.get() # path=''.join([aux,str(self.meas.get()),'.txt']) # g=pd.read_csv(path) f=read_panel_hdf5(aux, self.point.get(), self.meas.get()) f=4096-f recons,energia = DB.BLR( signal_daq=f.flatten().astype(float), coef=self.coef.get(), n_sigma=self.n_sigma.get(), NOISE_ADC=self.noise.get(), thr1=self.thr1.get(), thr2=self.thr2.get(), thr3=self.thr3.get(), plot=False) plt.figure(a) plt.plot(recons) plt.figtext(0.2,0.75, ('ENERGY = %0.2f ' % (energia))) plt.show()
def test_type42_font_without_prep(): # Test whether Type 42 fonts without prep table are properly embedded mpl.rcParams["ps.fonttype"] = 42 mpl.rcParams["mathtext.fontset"] = "stix" plt.figtext(0.5, 0.5, "Mass $m$")
def plot_1d(xdata, ydata, color, x_axis, y_axis, system, analysis, average=False, t0=0, marker_style=None, **kwargs): """ Creates a 1D scatter/line plot: Usage: plot_1d(xdata, ydata, color, x_axis, y_axis, system, analysis, average = [False|True], t0 = 0) Arguments: xdata, ydata: self-explanatory color: color to be used to plot data x_axis, y_axis: strings to be used for the axis label system: descriptor for the system that produced the data analysis: descriptor for the analysis that produced the data average: [False|True]; Default is False; if set to True, the function will calc the average, standard dev, and standard dev of mean of the y-data # THERE IS A BUG IF average=True; must read in yunits for this function to work at the moment. t0: index to begin averaging from; Default is 0 marker_style: default None; string that matches the desired marker style kwargs: xunits, yunits: string with correct math text describing the units for the x/y data x_lim, y_lim: list w/ two elements, setting the limits of the x/y ranges of plot plt_title: string to be added as the plot title draw_line: int value that determines the line style to be drawn; giving myself space to add more line styles if I decide I need them """ # INITIATING THE PLOT... plt.plot(xdata, ydata, '%s' % (color), marker=marker_style) # READING IN KWARG DICTIONARY INTO SPECIFIC VARIABLES for name, value in kwargs.items(): if name == 'xunits': x_units = value x_axis = '%s (%s)' % (x_axis, value) elif name == 'yunits': y_units = value y_axis = '%s (%s)' % (y_axis, value) elif name == 'x_lim': plt.xlim(value) elif name == 'y_lim': plt.ylim(value) elif name == 'plt_title': plt.title(r'%s' % (value), size='14') elif name == 'draw_line': draw_line = value if draw_line == 1: plt.plot([0, max(ydata)], [0, max(ydata)], 'r-', linewidth=2) else: print 'draw_line = %s has not been defined in plotting_functions script' % ( line_value) plt.grid(b=True, which='major', axis='both', color='#808080', linestyle='--') plt.xlabel(r'%s' % (x_axis), size=12) plt.ylabel(r'%s' % (y_axis), size=12) # CALCULATING THE AVERAGE/SD/SDOM OF THE Y-DATA if average != False: avg = np.sum(ydata[t0:]) / len(ydata[t0:]) SD = stdev(ydata[t0:]) SDOM = SD / sqrt(len(ydata[t0:])) plt.axhline(avg, xmin=0.0, xmax=1.0, c='r') plt.figtext(0.680, 0.780, '%s\n%6.4f $\\pm$ %6.4f %s \nSD = %4.3f %s' % (analysis, avg, SDOM, y_units, SD, y_units), bbox=dict(boxstyle='square', ec='r', fc='w'), fontsize=12) plt.savefig('%s.%s.plot1d.png' % (system, analysis), dpi=300) plt.close()
def plot_ROC_curve(network_output, y_true, identifier, meta=''): from sklearn.metrics import roc_curve, auc import matplotlib.pyplot as plt import seaborn as sns # Compute ROC curve, integrate y_pred = network_output fpr, tpr, thresholds = roc_curve(y_true, y_pred) roc_auc = auc(fpr, tpr) print('AUC: {}'.format(roc_auc)) plt.figure() plt.axes([.1, .1, .8, .75]) plt.figtext(.5, .95, r'Receiver Operating Characteristic', fontsize=15, ha='center') plt.figtext(.5, .9, meta, fontsize=10, ha='center') plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC (area = %0.3f)' % roc_auc) plt.plot([0, 1], [0, 1], color='navy', lw=1.0, linestyle='--') plt.xlim([-0.05, 1.05]) plt.ylim([-0.05, 1.05]) plt.xlabel(r'False Positive Rate') plt.ylabel(r'True Positive Rate') plt.legend(loc="lower right") plt.savefig(os.path.join('graphs', 'val_{}'.format(identifier) + 'ROC.pdf'), format='pdf', dpi=1000) plt.show() plt.gcf().clear() print('Plotting signal efficiency versus background rejection') plt.figure() plt.axes([.1, .1, .8, .75]) plt.figtext(.5, .95, r'Signal Efficiency v. Background Rejection', fontsize=15, ha='center') plt.figtext(.5, .9, meta, fontsize=10, ha='center') plt.plot(tpr, 1 - fpr, color='springgreen', lw=2, label='ROC (area = %0.3f)' % roc_auc) plt.xlim([-0.05, 1.05]) plt.ylim([-0.05, 1.05]) plt.xlabel(r'$\epsilon_S$') plt.ylabel(r'$1-\epsilon_B$') plt.legend(loc="upper right") plt.savefig(os.path.join('graphs', 'val_{}'.format(identifier) + 'SEvBR.pdf'), format='pdf', dpi=1000) plt.show() plt.gcf().clear()
def sci_plots(etable, gtitable, args): #GRID SET UP figure2 = plt.figure(figsize = (11, 8.5), facecolor = 'white') sci_grid = gridspec.GridSpec(5,7) # Build PHA Fast/Slow ratio plot before filtering by ratio # Only do this if powerspectrum not requested if not args.powspec: log.info('Building fast/slow subplot') plt.subplot(sci_grid[1:3,2:5]) plot_slowfast(etable,args) # Now, filter out the points above the ratio cut, if requested if args.filtratio: log.info('Applying ratio filter using trumpet') etable = filt_ratio_trumpet(etable) #Light Curve log.info('Building light curve') plt.subplot(sci_grid[3:5,:7]) meanrate, a = plot_light_curve(etable, args.lclog, gtitable, binsize=args.lcbinsize) plot.title('Light Curve') plot.xlabel('Time Elapsed (s)') #Energy Spectrum log.info('Building energy spectrum') plt.subplot(sci_grid[1:3,:2]) plot_energy_spec(etable) #Power Spectrum if args.powspec: log.info('Looking at power spectrum') plt.subplot(sci_grid[1:3,2:5]) # plot_fft_of_power(etable, args.nyquist, args.pslog, args.writeps) # PULSE PROFILE log.info('Building pulse profile') axprofile = plt.subplot(sci_grid[1:3,5:7]) if (args.orb is not None) and (args.par is not None): log.info('Calling pulse profile using PINT') pulse_profile(axprofile, etable, args) elif args.foldfreq > 0.0: log.info('Calling pulse profile with fixed frequency') pulse_profile_fixed(etable, args.foldfreq) else: pass #Making the plot all nice and stuff plt.subplots_adjust(left = .07, right = .99, bottom = .05, top = .9, wspace = .8, hspace = .8) figure2.suptitle('ObsID {0}: {1} on {2}'.format(etable.meta['OBS_ID'], etable.meta['OBJECT'],etable.meta['DATE-OBS'].replace('T',' at ')), fontsize=14) #tstart, tstop, exposure exposure = float(etable.meta['EXPOSURE']) #tstart = etable.meta['DATE-OBS'].replace('T',' at ') #tend = etable.meta['DATE-END'].replace('T', ' at ') tstart = TimeDelta(etable.meta['TSTART'], format='sec',scale='tt')+Time(etable.meta['MJDREFI']+etable.meta['MJDREFF'], format='mjd',scale='tt') tend = TimeDelta(etable.meta['TSTOP'], format='sec',scale='tt')+Time(etable.meta['MJDREFI']+etable.meta['MJDREFF'], format='mjd',scale='tt') fraction = exposure/(float(etable.meta['TSTOP'])-float(etable.meta['TSTART'])) # Add text info here: plt.figtext(.07, .93, 'Start time is {0}, End time is {1}'.format(tstart.iso,tend.iso), fontsize = 10) plt.figtext(.07, .90, 'Exposure is {0:.1f} s, Good time fraction is {1:.3f}'.format(exposure, fraction), fontsize = 10) plt.figtext(.07, .87, 'Mean count rate {0:.3f} c/s'.format(meanrate), fontsize = 10) # plt.figtext(.07, .84, etable.meta['FILT_STR'], fontsize=10) if args.mask: plt.figtext(.07, .81, 'IDS {0} are masked'.format(args.mask), fontsize=10) plt.figtext(.5, .77, str(gtitable['START'][:]), fontsize =9) plt.figtext(.58, .77, str(gtitable['STOP'][:]), fontsize =9) plt.figtext(.66, .77, str(gtitable['DURATION'][:]), fontsize =9) return figure2
weight="bold", position=(0.5, 1.1), horizontalalignment="center", verticalalignment="center", fontsize=13.) for d, color in zip(case_data, colors): ax.plot(theta, d, color=color) ax.fill(theta, d, facecolor=color, alpha=0.5) ax.set_varlabels(spoke_labels) plt.subplot(2, 2, 1) labels = kings legend = plt.legend(labels, loc=(.95, .95), labelspacing=0.1) plt.setp(legend.get_texts(), fontsize="large") plt.figtext(0.5, 0.965, "Types of Battles Fought By Kings as Attacker/Defender", ha="center", color="k", size=16.) plt.show() death_preds = character_predictions.copy(deep=True) from xgboost import plot_importance from xgboost import XGBClassifier as XGBC from sklearn.linear_model import LogisticRegression from sklearn.metrics import roc_auc_score, roc_curve, log_loss, confusion_matrix, precision_score, recall_score, classification_report, accuracy_score death_preds.loc[:, "culture"] = [ get_cult(x) for x in death_preds.culture.fillna("") ] death_preds.loc[:, "title"] = pd.factorize(death_preds.title)[0] death_preds.loc[:, "culture"] = pd.factorize(death_preds.culture)[0] death_preds.loc[:, "mother"] = pd.factorize(death_preds.mother)[0] death_preds.loc[:, "father"] = pd.factorize(death_preds.father)[0]
def view_sample(sample_id, all_samples, before=0.15, after=0.05, show_plot=True, save_plot=None): # Select the sample (i.e., the row from the data frame of samples) try: sample = all_samples.loc[sample_id] except KeyError: raise KeyError('Given sample_id is too big! Maximum value = {}'.format( len(all_samples) - 1)) # Check if the sample we have received contains an injection or not if 'h1_signal' in sample.keys(): has_injection = isinstance(sample['h1_signal'], np.ndarray) else: has_injection = False # Read out and construct some necessary values for plotting seconds_before_event = float(sample['seconds_before_event']) seconds_after_event = float(sample['seconds_after_event']) # seconds_after_event = 2.0 - seconds_before_event target_sampling_rate = float(sample['target_sampling_rate']) sample_length = float(sample['sample_length']) # sample_length = 2.0 # Create a grid on which the sample can be plotted so that the # `event_time` is at position 0 grid = np.linspace(0 - seconds_before_event, 0 + seconds_after_event, int(target_sampling_rate * sample_length)) # Create subplots for H1 and L1 fig, axes1 = plt.subplots(nrows=2) # If the sample has an injection, we need a second y-axis to plot the # (unwhitened) detector signals if has_injection: axes2 = [ax.twinx() for ax in axes1] else: axes2 = None # Plot the strains for H1, L1 and V1 max_strain = max(np.max(sample['h1_strain']), np.max(sample['l1_strain'])) for i, (det_name, det_string) in enumerate([('H1', 'h1_strain'), ('L1', 'l1_strain')]): axes1[i].plot(grid, sample[det_string] / max_strain, color='C0') axes1[i].set_xlim(-before, after) axes1[i].set_ylim(-150, 150) axes1[i].tick_params('y', colors='C0', labelsize=8) axes1[i].set_ylabel( 'Amplitude of Whitened Strain ({})'.format(det_name), color='C0', fontsize=8) # If applicable, also plot the detector signals for H1 and L1 if has_injection: # Get the maximum value of the detector signal (for norming them) maximum = max(np.max(sample['h1_signal']), np.max(sample['l1_signal'])) print('Maximum=', maximum) for i, (det_name, det_string) in enumerate([('H1', 'h1_signal'), ('L1', 'l1_signal')]): axes1[i].plot(grid, sample[det_string] / maximum, color='C1') # axes2[i].plot(grid, sample[det_string], color='C1') # axes1[i].set_xlim(-before, after) axes1[i].set_xlim(-seconds_before_event, seconds_after_event) axes1[i].set_ylim(-1.2, 1.2) axes1[i].tick_params('y', colors='C1', labelsize=8) axes1[i].set_ylabel('Amplitude of Simulated\n' 'Detector Signal ({})'.format(det_name), color='C1', fontsize=8) # axes2[i].set_ylabel('Amplitude of Simulated\n' # 'Detector Signal ({})'.format(det_name), # color='C1', fontsize=8) # Also add the injection parameters if has_injection: keys = ('mass1', 'mass2', 'spin1z', 'spin2z', 'ra', 'dec', 'coa_phase', 'inclination', 'polarization', 'injection_snr') string = ', '.join( ['{} = {:.2f}'.format(_, float(sample[_])) for _ in keys]) else: string = '(sample does not contain an injection)' plt.figtext(0.5, 0.9, 'Injection Parameters:\n' + string, fontsize=8, ha='center') # Add a vertical line at the position of the event (x=0) axes1[0].axvline(x=0, color='black', ls='--', lw=1) axes1[1].axvline(x=0, color='black', ls='--', lw=1) # Set x-labels # axes1[2].set_xticklabels([]) axes1[1].set_xlabel('Time from `event_time` (in seconds)') # Adjust the size and spacing of the subplots plt.gcf().set_size_inches(12, 6, forward=True) plt.tight_layout(rect=[0, 0, 1, 0.9]) plt.subplots_adjust(wspace=0, hspace=0.3) # Add a title plt.suptitle('Sample #{}'.format(sample_id), y=0.975) # If desired, save the resulting plot if save_plot is not None: plt.savefig(save_plot) # If desired, show the resulting plot if show_plot: plt.show()
""" Name : c15_10_volatility_smile_put.py Book : Python for Finance (2nd ed.) Publisher: Packt Publishing Ltd. Author : Yuxing Yan Date : 6/6/2017 email : [email protected] [email protected] """ import numpy as np import pandas as pd import matplotlib.pyplot as plt infile = "c:/temp/puts17march.txt" data = pd.read_table(infile, skiprows=1) x = data['Strike'] y0 = list(data['Implied Volatility']) n = len(y0) y = [] for i in np.arange(n): a = float(y0[i].replace("%", "")) / 100. y.append(a) print(a) # plt.title("Volatility smile") plt.figtext(0.55, 0.80, "IBM puts") plt.figtext(0.55, 0.75, "maturity: 3/17/2017") plt.ylabel("Volatility") plt.xlabel("Strike Price") plt.plot(x, y, 'o') plt.show()
plt.axis('tight') if int(dates[1][4:6]) > 10 or int(dates[2][4:6]) < 4: plt.xlim(2.5,4.0) else: plt.xlim(2.2,3.4) plt.ylim(levbot,levtop) plt.grid(True) plt.subplot(1,2,2) temp_fits1mean = np.sqrt(temp_fits1).mean(axis=0) temp_fits2mean = np.sqrt(temp_fits2).mean(axis=0) temp_fits_pval = ttest(temp_fits1,temp_fits2,inflate=True) sig = temp_fits_pval >= sigthresh plt.plot(temp_fits1mean,levels,color=color1,linewidth=linewidth1,marker='o',label=expt1) plt.plot(temp_fits2mean,levels,color=color2,linewidth=linewidth2,marker='o',label=expt2) for n in range(len(levels)): if sig[n]: plt.axhspan(levels_up[n], levels_down[n], facecolor='lightgoldenrodyellow') plt.xlabel('RMS (K)') plt.title('%s: %s' % (obtypes+' T',region)) plt.axis('tight') plt.xlim(0.5,1.4) plt.ylim(levbot,levtop) plt.grid(True) plt.legend(loc=0) plt.figtext(0.5,0.93,'%s RMS O-F (%s)' % (title,dates_txt),horizontalalignment='center',fontsize=18) plt.savefig('obfits_%s_%s_%s.png' % (expt1,expt2,region)) plt.show()
def hist1d(data, x_axis, system, analysis, num_b=100, norm=False, average=False, t0=0, **kwargs): """ Creates a 1D histogram: Usage: hist1d(data, x_axis, num_b, system, analysis, norm) Arguments: data: self-explanatory x_axis: string to be used for the axis label system: descriptor for the system analyzed analysis: descriptor for the analysis performed and plotted num_b: number of bins to be used when binning the data; Default is 100 norm = [False][True]; Default is False; if False, plotting a frequency of data; if True, plotting a probability density average: [False|True]; Default is False; if set to True, the function will calc the average, standard dev, and standard dev of mean of the y-data t0: index to begin averaging from; Default is 0 kwargs: xunits: string with correct math text describing the units for the x data x_lim, y_lim: list w/ two elements, setting the limits of the x/y ranges of plot plt_title: string to be added as the plot title """ # INITIATING THE PLOT... events, edges, patches = plt.hist(data, bins=num_b, histtype='bar', normed=norm) # READING IN KWARG DICTIONARY INTO SPECIFIC VARIABLES for name, value in kwargs.items(): if name == 'xunits': x_units = value x_axis = '%s (%s)' % (x_axis, value) elif name == 'x_lim': plt.xlim(value) elif name == 'y_lim': plt.ylim(value) elif name == 'plt_title': plt.title(r'%s' % (value), size='14') plt.grid(b=True, which='major', axis='both', color='#808080', linestyle='--') plt.xlabel(r'%s' % (x_axis), size=12) # CALCULATING THE AVERAGE/SD/SDOM OF THE Y-DATA if average != False: avg = np.sum(data[t0:]) / len(data[t0:]) SD = stdev(data[t0:]) SDOM = SD / sqrt(len(data[t0:])) plt.axvline(avg, ymin=0.0, ymax=1.0, c='r') plt.figtext(0.680, 0.780, '%s\n%6.4f $\\pm$ %6.4f %s \nSD = %4.3f %s' % (analysis, avg, SDOM, x_units, SD, x_units), bbox=dict(boxstyle='square', ec='r', fc='w'), fontsize=12) if norm == True: plt.ylabel('Probability Density') plt.savefig('%s.%s.prob1d.png' % (system, analysis), dpi=300) nf = open('%s.%s.prob1d.dat' % (system, analysis), 'w') else: plt.ylabel('Frequency', size=12) plt.savefig('%s.%s.hist1d.png' % (system, analysis), dpi=300) nf = open('%s.%s.hist1d.dat' % (system, analysis), 'w') for i in range(len(events)): nf.write('%10.1f %10.4f\n' % (events[i], edges[i])) plt.close() nf.close() events = [] edges = [] patches = []
def scat_hist(xdata, ydata, color, x_axis, y_axis, system, analysis, num_b=100, average=False, t0=0, **kwargs): """ Creates 1D scatter plot w/ a 1D histogram Usage: scat_hist(xdata, ydata, color, x_axis, y_axis, system, analysis, num_b) Arguments: xdata, ydata: self-explanatory color: color to be used to plot data x_axis, y_axis: strings to be printed on the axi labels system: descriptor for the system analyzed analysis: descriptor for the analysis performed and plotted num_b: number of bins to be used when binning the data; Default is 100 average: [False|True]; Default is False; if set to True, the function will calc the average, standard dev, and standard dev of mean of the y-data # THERE IS A BUG; if average = True, need to read in xunits for this function to work... t0: index to begin averaging from; Default is 0 kwargs: xunits, yunits: string with correct math text describing the units for the x/y data x_lim, y_lim: list w/ two elements, setting the limits of the x/y ranges of plot plt_title: string to be added as the plot title """ # INITIATING THE PLOT SIZES left, width = 0.1, 0.65 bottom, height = 0.1, 0.8 bottom_h = left_h = left + width + 0.01 rect_scatter = [left, bottom, width, height] rect_histy = [left_h, bottom, 0.2, height] # INITIATING THE PLOT... plt.figure(1, figsize=(10, 8)) axScatter = plt.axes(rect_scatter) axScatter.plot(xdata, ydata, '%s.' % (color)) # READING IN KWARG DICTIONARY INTO SPECIFIC VARIABLES for name, value in kwargs.items(): if name == 'xunits': x_units = value x_axis = '%s (%s)' % (x_axis, value) elif name == 'yunits': y_units = value y_axis = '%s (%s)' % (y_axis, value) elif name == 'x_lim': plt.xlim(value) elif name == 'y_lim': plt.ylim(value) elif name == 'plt_title': plt.title(r'%s' % (value), size='14') plt.grid(b=True, which='major', axis='both', color='#808080', linestyle='--') plt.ylabel(r'%s' % (y_axis), size=20) plt.xlabel(r'%s' % (x_axis), size=20) axScatter.tick_params(axis='both', which='major', labelsize=14) if average != False: avg = np.sum(ydata[t0:]) / len(ydata[t0:]) SD = stdev(ydata[t0:]) SDOM = SD / sqrt(len(ydata[t0:])) plt.axhline(avg, xmin=0.0, xmax=1.0, c='r') axHisty = plt.axes(rect_histy) axHisty.yaxis.set_major_formatter(nullfmt) axHisty.xaxis.set_major_formatter(nullfmt) plt.grid(b=True, which='major', axis='both', color='#808080', linestyle='--') axHisty.hist(ydata, bins=num_b, orientation='horizontal', facecolor='grey', edgecolor='black') axHisty.set_ylim(axScatter.get_ylim()) # CALCULATING THE AVERAGE/SD/SDOM OF THE Y-DATA if average != False: plt.axhline(avg, xmin=0.0, xmax=1.0, c='r') plt.figtext(0.775, 0.810, '%s\n%6.4f $\\pm$ %6.4f %s \nSD = %4.3f %s' % (analysis, avg, SDOM, y_units, SD, y_units), bbox=dict(boxstyle='square', ec='r', fc='w'), fontsize=12) plt.savefig('%s.%s.scat_hist.png' % (system, analysis), dpi=300) plt.close()
theta = radar_factory(N, frame='polygon') data = example_data() spoke_labels = data.pop('column names') fig = plt.figure(figsize=(9, 9)) fig.subplots_adjust(wspace=0.25, hspace=0.20, top=0.85, bottom=0.05) colors = ['b', 'r', 'g', 'm', 'y'] # Plot the four cases from the example data on separate axes for n, title in enumerate(data.keys()): ax = fig.add_subplot(2, 2, n + 1, projection='radar') plt.rgrids([0.2, 0.4, 0.6, 0.8]) ax.set_title(title, weight='bold', size='medium', position=(0.5, 1.1), horizontalalignment='center', verticalalignment='center') for d, color in zip(data[title], colors): print(d) ax.plot(theta, d, color=color) ax.fill(theta, d, facecolor=color, alpha=0.25) ax.set_varlabels(spoke_labels) # add legend relative to top-left plot plt.subplot(2, 2, 1) labels = ('Factor 1', 'Factor 2', 'Factor 3', 'Factor 4', 'Factor 5') legend = plt.legend(labels, loc=(0.9, .95), labelspacing=0.1) plt.setp(legend.get_texts(), fontsize='small') plt.figtext(0.5, 0.965, '5-Factor Solution Profiles Across Four Scenarios', ha='center', color='black', weight='bold', size='large') plt.show()
pyplot.plot(TestData.index, TestData['GWL'], 'b', label ="observed") pyplot.title("CNN - Forecast 3 Months seq2seq: "+Well_ID, size=15) pyplot.ylabel('GWL [m asl]', size=12) pyplot.xlabel('Date',size=12) pyplot.legend(fontsize=12,bbox_to_anchor=(1.2, 1),loc='upper right') pyplot.tight_layout() s = """NSE = {:.2f}\nR² = {:.2f}\nRMSE = {:.2f}\nrRMSE = {:.2f} Bias = {:.2f}\nrBias = {:.2f}\nPI = {:.2f}\n\nfilters = {:d}\ndense-size = {:d}\nin_seqlength = {:d} out_seqlength = {:d}\nbatchsize = {:d}\nrH = {:d}\nT = {:d}\nTsin = {:d}""".format(scores.NSE[0],scores.R2[0], scores.RMSE[0],scores.rRMSE[0],scores.Bias[0],scores.rBias[0],scores.PI[0], filters_int, densesize_int,seqlength_int,12,batchsize_int,rH,T,Tsin) # pyplot.figtext(0.865, 0.18, s, bbox=dict(facecolor='white')) pyplot.figtext(0.856, 0.4, s, bbox=dict(facecolor='white')) pyplot.savefig(Well_ID+'_testset_CNN_seq2seq.png', dpi=300) pyplot.show() # print log summary file f = open('./log_summary_CNN_seq2seq_'+Well_ID+'.txt', "w") print("\nBEST:\n\n"+s+"\n", file = f) print("best iteration = {}".format(step+1), file = f) print("max iteration = {}\n".format(len(optimizer.res)), file = f) for i, res in enumerate(optimizer.res): print("Iteration {}: \t{}".format(i+1, res), file = f) f.close() #print sim data for i in range(inimax): printdf = pd.DataFrame(data=testresults_members[:,:,i],index=TestData.index)
def main(session: str, dims: int = 32, pooling: str = 'stride', batch_size: int = 16, epochs: int = 75, normalization: str = 'batch', v_normalization: str = 'global', weights=None, workers: int = 1, l2: float = 0.01, kernel_initializer: str = 'glorot_uniform', random_seed: int = None, cmd='train', paper_mode: int = 0): assert os.access('.', os.W_OK | os.R_OK) if cmd != 'salience': tf.compat.v1.disable_eager_execution() if random_seed is not None: np.random.seed(random_seed) tf.random.set_seed(random_seed) random.seed(random_seed) gpus = tf.config.experimental.list_physical_devices('GPU') if gpus: try: # Currently, memory growth needs to be the same across GPUs for gpu in gpus: tf.config.experimental.set_memory_growth(gpu, True) logical_gpus = tf.config.experimental.list_logical_devices('GPU') print(len(gpus), "Physical GPUs,", len(logical_gpus), "Logical GPUs") except RuntimeError as e: # Memory growth must be set before GPUs have been initialized print(e) if l2 is not None: kernel_regularizer = l2r(l2) else: kernel_regularizer = None model, loss_fns, metrics = residual_model( dims=dims, pooling=pooling, kernel_regularizer=kernel_regularizer, kernel_initializer=kernel_initializer) if weights is not None: model.load_weights(weights, by_name=True) optimizer = SGD(lr=1e-4, momentum=0.9) model.compile(optimizer=optimizer, loss=loss_fns, metrics=metrics) try: os.mkdir('weights') except FileExistsError: assert os.access('weights', os.W_OK | os.R_OK) filepath = "weights/%s_epoch-{epoch:02d}_val_auc-{val_auc:.4f}.h5" % session checkpoint = ModelCheckpoint(filepath, monitor='val_auc', verbose=1, save_best_only=True, mode='max') def sched(epoch): return 1e-4 * 0.5**(np.floor(epoch / 15)) reduce_lr = LearningRateScheduler(schedule=sched) try: os.mkdir('logs') except FileExistsError: assert os.access('logs', os.W_OK | os.R_OK) if os.path.exists('logs/%s' % session): assert os.access('logs/%s' % session, os.W_OK | os.R_OK) tensorboard = TensorBoard(log_dir='logs/%s' % session, profile_batch=0) if cmd == 'train': Xy = np.load('data/train.npy', mmap_mode='r') X_train = Xy[:, :, 1:11] y_train = Xy[:, :, 0] d_train = np.load('data/train_props.npy') d_train = np.piecewise(d_train, [ d_train == 0, np.logical_and(0 < d_train, d_train <= 1 / 10), 1 / 10 < d_train ], [0.95, lambda x: 10 * x, 1]) train_seq = SMBISequence(X=X_train, y=y_train, d=d_train, stage='train', batch_size=batch_size, normalization=normalization) X_test = np.swapaxes(np.load('data/test_inps.p', mmap_mode='r'), 1, 2) y_test = np.load('data/test_labels.p', mmap_mode='r') p_test = np.load('data/test_pids.p', mmap_mode='r') val_seq = SMBISequence(X=X_test, y=y_test, stage='test', batch_size=batch_size, normalization=v_normalization) validation_metrics = ValidationMetrics(seq=val_seq, batch_size=batch_size, seqlen=2000, n_feat=10) callbacks = [validation_metrics, checkpoint, reduce_lr, tensorboard] if cmd == 'train': model.fit_generator( train_seq, validation_data=val_seq, epochs=epochs, callbacks=callbacks, use_multiprocessing=True if workers != 1 else False, workers=workers, shuffle=True) if cmd == 'eval': if weights is not None: model.load_weights(weights) validation_metrics.model = model validation_metrics.on_epoch_end(0) if cmd == 'salience': import matplotlib.pyplot as plt import matplotlib.cm as cm val_seq_nonorm = SMBISequence(X=X_test, y=y_test, p=p_test, stage='test', batch_size=batch_size, normalization='none') gidx = 0 onset = False onset_idx = 0 for bidx in range(0, len(val_seq)): model_seq, model_cls, _ = val_seq.__getitem__(bidx) vis_input, _, _ = val_seq_nonorm.__getitem__(bidx) vis_seq = vis_input[0] vis_p = vis_input[1] for sidx in range(0, batch_size): input_seq = model_seq[sidx] input_seq_v = vis_seq[sidx] output_cls = model_cls[sidx][0] wrt = np.array([input_seq.astype(np.float32)]) wrt_t = tf.constant(wrt) with tf.GradientTape() as g: g.watch([wrt_t]) evaluated_cls = model([wrt_t]) evaluated_gradients = np.abs( g.gradient(evaluated_cls, [wrt_t])[0][0].numpy()) evaluated_gradients_all = np.sum(evaluated_gradients, axis=-1) if bool(output_cls): if not onset: onset = True onset_idx = 1999 else: if onset: onset = False if paper_mode: fig = plt.figure(figsize=(10, 5)) plt.title('Patient %d' % vis_p[sidx]) else: fig = plt.figure(figsize=(10, 5), facecolor='#808080') plt.figtext( 0.01, 0.01, 'Model: Residual CNN\nCarroll Vance <*****@*****.**>' ) plt.title( 'GTC seizure onset of slow activity prediction w/ saliency: Patient %d' % vis_p[sidx]) ax = fig.gca() t = np.array([i for i in range(0, 2000)]) xlim = (0, 2000) ylim = (0, np.max(evaluated_gradients_all)) vmin = ylim[0] vmax = ylim[1] for i in range(0, 10): plt.plot(t, input_seq_v[:, i]) ax.pcolorfast(xlim, ax.get_ylim(), evaluated_gradients_all[np.newaxis], vmin=vmin, vmax=vmax, cmap='viridis') plt.grid() locs = [i * 200 for i in range(0, 11)] labels = ["%d" % (int(loc / 200)) for loc in locs] plt.legend([ 'fp1-f7', 'f7-t7', 't7-p7', 'p7-o1', 'fp2-f8', 'f8-t8', 't8-p8', 'p8-o2', 'fz-cz', 'cz-pz' ], fontsize='small', loc='upper left') plt.xticks(locs, labels) plt.ylabel("Amplitude") plt.xlabel("Seconds") cb_pred = plt.colorbar(cm.ScalarMappable(cmap='viridis'), ticks=[0.0, 0.25, 0.5, 0.75, 1.0]) if bool(np.round(evaluated_cls)) == bool(np.round(output_cls)): textcolor = '#00EE00' if bool(np.round(output_cls)): outcome = 'TP' else: outcome = 'TN' else: textcolor = 'red' if bool(np.round(evaluated_cls)): outcome = 'FP' else: outcome = 'FN' if onset: cb_pred.ax.plot(0.5, evaluated_cls, '_', markersize=96, color='magenta', markeredgewidth=3) cb_pred.ax.annotate("Positive", (0.5, 1.0), xytext=(-0.75, 1.02), color='red') else: cb_pred.ax.plot(0.5, evaluated_cls, '_', markersize=96, color='magenta', markeredgewidth=3) cb_pred.ax.annotate("Negative", (0.5, 0.0), xytext=(-0.75, -0.05), color='#00EE00') cb_pred.ax.set_ylabel('Prediction: %s' % outcome, color=textcolor) if onset: plt.annotate("Onset", (onset_idx, 0), color='red', xytext=(onset_idx, np.max(input_seq_v)), arrowprops=dict(color='red', width=1., headwidth=6.)) onset_idx -= 20 if paper_mode: plt.savefig('figs/%d.png' % gidx) else: plt.savefig('figs/%d.png' % gidx, facecolor='#808080') plt.close('all') print(gidx) gidx += 1
for i in range(10): ax1[i].tick_params( axis='y', # changes apply to the y-axis labelleft=False) for i in range(10): ax2[i].tick_params( axis='y', # changes apply to the y-axis labelleft=False) for i in range(10): ax3[i].tick_params( axis='y', # changes apply to the y-axis labelleft=False) plt.figtext(0.02, 0.82, 'V (mV)', rotation=90, fontsize='large') plt.figtext(0.005, 0.94, 'A', fontsize='xx-large') plt.figtext(0.005, 0.5, 'B', fontsize='xx-large') #plt.figtext(0.005,0.42,'C',fontsize = 'xx-large') plt.figtext(0.005, 0.18, 'C', fontsize='xx-large') #ax2[4].text(522,1025,r'$\mathsf{t_{1} }$',fontsize = 'x-large') #ax2[4].text(535,1025,r'$\mathsf{t_{2} }$',fontsize = 'x-large') plt.figtext(0.965, 0.97, r'$\mathsf{J_{gap} }$', fontsize='large') ax11 = [ax1[4], ax2[4], ax3[4], ax3[9]] S = [0.0, 0.05, 0.1, 1.0] for ax0, s0 in zip(ax11, S):
def plot_avg_both(real_data, fake_data, n_events, epoch, imageSize, withMarginals=True, save_dir=None): fig = plt.figure(figsize=(10, 5)) xran = (-50, 50) yran = (-50, 50) extent = xran + yran #real_data = real_image img = real_data test_unnormed = fake_data test_noNans = np.copy(test_unnormed) img2 = np.squeeze(test_noNans) t = np.arange(-50, 50, 100 / float(imageSize)) #t = np.arange(img.shape[0]) f = np.arange(-50, 50, 100 / float(imageSize)) #f = np.arange(img.shape[1]) flim = (f.min(), f.max()) tlim = (t.min(), t.max()) gs = gridspec.GridSpec(2, 4, width_ratios=[5, 1, 1, 5], height_ratios=[1, 5]) gs.update(hspace=0, wspace=0) ax1 = fig.add_subplot(gs[1, 0]) axl = fig.add_subplot(gs[1, 1], sharey=ax1) axb = fig.add_subplot(gs[0, 0], sharex=ax1) ax2 = fig.add_subplot(gs[1, 3]) axl2 = fig.add_subplot(gs[1, 2], sharey=ax2) axb2 = fig.add_subplot(gs[0, 3], sharex=ax2) plt.setp(axl.get_yticklabels(), visible=False) plt.setp(axb.get_xticklabels(), visible=False) plt.setp(axl.get_xticklabels(), visible=False) plt.setp(axb.get_yticklabels(), visible=False) plt.setp(axl2.get_yticklabels(), visible=False) plt.setp(axb2.get_xticklabels(), visible=False) plt.setp(axl2.get_xticklabels(), visible=False) plt.setp(axb2.get_yticklabels(), visible=False) axl.yaxis.set_ticks_position('none') axb.xaxis.set_ticks_position('none') axl.xaxis.set_ticks_position('none') axb.yaxis.set_ticks_position('none') axl2.yaxis.set_ticks_position('none') axb2.xaxis.set_ticks_position('none') axl2.xaxis.set_ticks_position('none') axb2.yaxis.set_ticks_position('none') cmap = sns.cubehelix_palette(dark=0.4, light=0.915, gamma=2.5, hue=1, start=0, as_cmap=True) im = ax1.imshow(real_data, vmin=0, extent=extent, origin='lower', cmap=cmap) ax1.spines["top"].set_visible(False) ax1.spines['right'].set_visible(False) #ax.spines['left'].set_visible(False) color_list = sns.cubehelix_palette(dark=0.4, light=0.915, gamma=2.5, hue=1).as_hex() axl.fill_between(img.mean(1), f, alpha=0.7, color=color_list[1]) axl.spines["top"].set_visible(False) axl.spines['right'].set_visible(False) axl.spines['left'].set_visible(False) axl.spines['bottom'].set_visible(False) axb.fill_between(t, img.mean(0), alpha=0.7, color=color_list[1]) axb.spines["top"].set_visible(False) axb.spines["right"].set_visible(False) axb.spines["left"].set_visible(False) axb.spines["bottom"].set_visible(False) ax1.set_xlim(tlim) ax1.set_ylim(tlim) #RECONSIDER TAKING OUT THE LESS THAN 0 VALUES #real_data[real_data < 0.0] = np.nan #test_unnormed[test_unnormed < 0.0] = np.nan print type(img2), type(img) test_unnormed = np.squeeze(test_unnormed) im = ax2.imshow(test_unnormed, vmin=0, extent=extent, origin='lower', cmap=cmap) ax2.spines["top"].set_visible(False) ax2.spines['left'].set_visible(False) axl2.fill_between(img2.mean(1), f, alpha=0.7, color=color_list[1]) axl2.invert_xaxis() axl2.spines["top"].set_visible(False) axl2.spines['right'].set_visible(False) axl2.spines['left'].set_visible(False) axl2.spines['bottom'].set_visible(False) axb2.fill_between(t, img2.mean(0), alpha=0.7, color=color_list[1]) axb2.spines["top"].set_visible(False) axb2.spines["right"].set_visible(False) axb2.spines["left"].set_visible(False) axb2.spines["bottom"].set_visible(False) ax2.set_xlim(tlim) ax2.set_ylim(tlim) ax1.set_xlabel("Real", fontsize=11) ax2.set_xlabel("VAE", fontsize=11) ax1.set_ylabel(r"$\mathit{y}$", fontsize=12, rotation=0) ax1.yaxis.set_label_coords(-0.07, 0.98) fig.tight_layout(rect=[0, 0, .9, 1]) cbar_ax = fig.add_axes([0.9, 0.25, 0.025, 0.45]) cb = fig.colorbar(im, cax=cbar_ax) cb.set_label(r'$E_{dep}$ (MeV)', y=0.85) plt.figtext(0.05, 0.060, r"$\mathit{x}$", fontsize=12) fig.subplots_adjust(wspace=0.1, hspace=0) fig.suptitle(r" CVAE Avg $E_{dep}$ Over " + str(n_events) + " Events, " + str(imageSize) + "x" + str(imageSize) + " \n Image Size, " + str(epoch) + " Epochs", x=0.46, y=0.02) if save_dir != None: #learning_rate = '%.0E' % Decimal(lr) #directory = "/home/chris/Documents/MPhilProjects/ForViewing/plots/Geant4/SingleLayerEGun/VAE/" filename = "CVAE_RealandFakeAvgEdep" + str( withMarginals) + "Over" + str(n_events) + "Events_Epoch" + str( epoch) + ".png" plt.savefig(save_dir + filename, bbox_inches='tight') plt.show() return
import pandas as p import matplotlib.pyplot as plt #reading training data set data=p.read_csv('train.csv') X_train= data.iloc[:, :-1].values Y_train= data.iloc[:, 1].values #fitting training dataset from sklearn.linear_model import LinearRegression lin_reg = LinearRegression() lin_reg.fit(X_train,Y_train) #reading test dataset data1=p.read_csv("test.csv") X_test= data1.iloc[:, :-1].values Y_test= data1.iloc[:, 1].values #predicting Y_predict=lin_reg.predict(X_test) #plot plt.scatter(X_test,Y_test,color='purple') plt.plot(X_train,lin_reg.predict(X_train),color='orange') plt.figtext(.2, .7, "Test set result = purple") plt.figtext(.2, .6, "Predicted result = orange") plt.title('Linear Regression Model') plt.ylabel('Amount (in lakhs)') plt.xlabel('Time invested') plt.show()
#set axis limits plt.ylim(1e9, 1e12) #adjust tick label font size label_size = 22 matplotlib.rcParams['xtick.labelsize'] = label_size matplotlib.rcParams['ytick.labelsize'] = label_size # do it this way!!: #plt.rcParams.update[{'font.size':20}] # add a legend with some customizations. legend = ax.legend(loc='lower right', fontsize='x-large') #add figure text plt.figtext(0.15, 0.83, 'Milky Way Mass Profile', fontsize=22) # Save to a file ax.set_rasterized(True) plt.savefig('MassProfile_MW.eps', rasterized=True, dpi=350) # Plot the Mass Profile for M31. #################################### fig = plt.figure(figsize=(10, 10)) ax = plt.subplot(111) # Plot mass enclosed for Halo plt.semilogy(R, M31.MassEnclosed(1, R), color='blue',
simulations[run] = stock_monte_carlo(start_price,days,mu,sigma)[days-1]; # In[64]: # Now we'lll define q as the 1% empirical qunatile, this basically means that 99% of the values should fall between here q = np.percentile(simulations, 1) # Now let's plot the distribution of the end prices plt.hist(simulations,bins=200) # Using plt.figtext to fill in some additional information onto the plot # Starting Price plt.figtext(0.6, 0.8, s="Start price: $%.2f" %start_price) # Mean ending price plt.figtext(0.6, 0.7, "Mean final price: $%.2f" % simulations.mean()) # Variance of the price (within 99% confidence interval) plt.figtext(0.6, 0.6, "VaR(0.99): $%.2f" % (start_price - q,)) # Display 1% quantile plt.figtext(0.15, 0.6, "q(0.99): $%.2f" % q) # Plot a line at the 1% quantile result plt.axvline(x=q, linewidth=4, color='r') # Title plt.title(u"Final price distribution for Google Stock after %s days" % days, weight='bold');
ax = plt.subplot(111) ax.plot(xp, yp, linewidth=1) # Display trapezoid rule errors by sampling just a few points a, b = 2, 9 # integral area npts = 4 # make the shaded region ix = np.linspace(a, b, npts) iy = func(ix) verts = [(a, 0)] + zip(ix, iy) + [(b, 0)] poly = plt.Polygon(verts, facecolor='0.8', edgecolor='k') ax.add_patch(poly) ax.scatter(ix, iy, zorder=2) # Fancify plot with labels and clean axes plt.text(0.5 * (a + b), 30, r"$\int_a^b f(x)\mathrm{d}x$", horizontalalignment='center', fontsize=20) plt.axis([0, 10, 0, 180]) plt.figtext(0.9, 0.05, 'x') plt.figtext(0.1, 0.9, 'y') plt.title('Trapezoid rule integration') ax.set_xticks((a, b)) ax.set_xticklabels(('a', 'b')) ax.set_yticks([]) plt.show()
def _plot_topo(info, times, show_func, click_func=None, layout=None, vmin=None, vmax=None, ylim=None, colorbar=None, border='none', axis_facecolor='k', fig_facecolor='k', cmap='RdBu_r', layout_scale=None, title=None, x_label=None, y_label=None, font_color='w', unified=False, img=False, axes=None): """Plot on sensor layout.""" import matplotlib.pyplot as plt if layout.kind == 'custom': layout = deepcopy(layout) layout.pos[:, :2] -= layout.pos[:, :2].min(0) layout.pos[:, :2] /= layout.pos[:, :2].max(0) # prepare callbacks tmin, tmax = times[[0, -1]] click_func = show_func if click_func is None else click_func on_pick = partial(click_func, tmin=tmin, tmax=tmax, vmin=vmin, vmax=vmax, ylim=ylim, x_label=x_label, y_label=y_label, colorbar=colorbar) if axes is None: fig = plt.figure() axes = plt.axes([0.015, 0.025, 0.97, 0.95]) _set_ax_facecolor(axes, fig_facecolor) else: fig = axes.figure if colorbar: sm = plt.cm.ScalarMappable(cmap=cmap, norm=plt.Normalize(vmin, vmax)) sm.set_array(np.linspace(vmin, vmax)) cb = fig.colorbar(sm, ax=axes, pad=0.025, fraction=0.075, shrink=0.5, anchor=(-1, 0.5)) cb_yticks = plt.getp(cb.ax.axes, 'yticklabels') plt.setp(cb_yticks, color=font_color) axes.axis('off') my_topo_plot = _iter_topography(info, layout=layout, on_pick=on_pick, fig=fig, layout_scale=layout_scale, axis_spinecolor=border, axis_facecolor=axis_facecolor, fig_facecolor=fig_facecolor, unified=unified, img=img, axes=axes) for ax, ch_idx in my_topo_plot: if layout.kind == 'Vectorview-all' and ylim is not None: this_type = {'mag': 0, 'grad': 1}[channel_type(info, ch_idx)] ylim_ = [v[this_type] if _check_vlim(v) else v for v in ylim] else: ylim_ = ylim show_func(ax, ch_idx, tmin=tmin, tmax=tmax, vmin=vmin, vmax=vmax, ylim=ylim_) if title is not None: plt.figtext(0.03, 0.95, title, color=font_color, fontsize=15, va='top') return fig
if len(subax) < 3: bottomax2.spines['right'].set_visible(False) bottomax2.yaxis.set_major_locator(plt.NullLocator()) if len(subax) == 3: bottomax2.set_ylabel('$\Delta$T from Previous Year ($^\circ$C)') dataframe_ttest(y, bottomax) subax.append([bottomax, bottomax2]) fig.suptitle( 'Does Crop Yield$^1$ change as Surface Temperatures$^2$ Rise for\n' + 'the World and Economic Country Groups$^3$ from 1961-2018') # Proxy artist for line plot legend entry blueline = mlines.Line2D([], [], color='C0') fig.legend((blueline, wbar), ('Crop Yield', '$\Delta$T')) plt.figtext( 0.005, 0.9, '$^1$ Crop data source - http:/www.fao.org/faostat/en/#data/QC\n' + '$^2$ Temperature data source - http:/www.fao.org/faostat/en/#data/ET\n' + '$^3$ Economic Country Groups according to UN M49 (2009)\n' + '- This is a general analysis. Underlying or additional factors\nare not considered.', horizontalalignment='left') plt.show()
def test_partial_usetex(caplog): caplog.set_level("WARNING") plt.figtext(.5, .5, "foo", usetex=True) plt.savefig(io.BytesIO(), format="ps") assert caplog.records and all("as if usetex=False" in record.getMessage() for record in caplog.records)
def plot_2f_variability(dic, x_train, y_train, x_test, y_test): """ Plots decision boundaries for a discrimination problem with 2 features in function of the training set draws. Superimposed with scatter plots of both training and test sets. """ #### PLOT #### nullfmt = NullFormatter() # definitions for the axes left, width = 0.1, 0.65 bottom, height = 0.1, 0.65 bottom_h = left_h = left + width + 0.02 rect_scatter = [left, bottom, width, height] rect_histx = [left, bottom_h, width, 0.2] rect_histy = [left_h, bottom, 0.2, height] # start with a rectangular Figure fig = plt.figure(1, figsize=(8, 8)) fig.set_facecolor('white') axScatter = plt.axes(rect_scatter) axHistx = plt.axes(rect_histx) axHisty = plt.axes(rect_histy) # No labels axHistx.xaxis.set_major_formatter(nullfmt) axHisty.yaxis.set_major_formatter(nullfmt) # Scatter plot: from LR_functions import normalize x_train, x_test = normalize(x_train, x_test) feat_1 = x_test.columns[0] feat_2 = x_test.columns[1] axScatter.scatter(x_test[feat_1], x_test[feat_2], c=list(y_test.NumType.values), cmap=plt.cm.gray, alpha=.2) axScatter.scatter(x_train[feat_1], x_train[feat_2], c=list(y_train.NumType.values), cmap=plt.cm.winter, alpha=.5) # Plot decision boundaries x_vec = np.arange(-1, 1, .01) rates = [] for draw in sorted(dic): theta = dic[draw]['out']['thetas'] t = dic[draw]['out']['threshold'] rates.append(dic[draw]['out']['rate_test']['global']) db = -1. / theta[1][2] * (theta[1][0] + np.log( (1 - t[1]) / t[1]) + theta[1][1] * x_vec) axScatter.plot(x_vec, db, lw=1., c=(0, 0.1 * draw, 1)) imax = np.argmax(rates) theta = dic[imax]['out']['thetas'] t = dic[imax]['out']['threshold'] method = dic[imax]['out']['method'].upper() types = dic[imax]['out']['types'] lab = r'%s %.1f$\pm$%.1f%%' % (method, np.mean(rates), np.std(rates)) db_max = -1. / theta[1][2] * (theta[1][0] + np.log( (1 - t[1]) / t[1]) + theta[1][1] * x_vec) axScatter.plot(x_vec, db_max, lw=3., c='midnightblue', label=lab) axScatter.legend(loc=4) x_vec, y_vec, proba, map = class_2c_2f(theta, t) axScatter.contourf(x_vec, y_vec, map, cmap=plt.cm.gray, alpha=0.2) # Determine nice limits by hand bins_1, bins_2 = plot_limits(x_test, x_train) axScatter.set_xlim((bins_1[0], bins_1[-1])) axScatter.set_ylim((bins_2[0], bins_2[-1])) axScatter.set_xlabel(feat_1) axScatter.set_ylabel(feat_2) # Plot histograms and PDFs plot_histos_and_pdfs_kde(axHistx, axHisty, bins_1, bins_2, x_test, y_test, x_train=x_train, y_train=y_train) axHistx.set_xlim(axScatter.get_xlim()) axHisty.set_ylim(axScatter.get_ylim()) # Display success rates pos_x = .76 pos_y_ini = .95 pas = .025 plt.figtext(pos_x, pos_y_ini, 'Training set %s' % method) rate_tr, rate_tr_1, rate_tr_2 = [], [], [] for draw in sorted(dic): p = dic[draw]['out']['rate_train'] rate_tr.append(p['global']) for key in sorted(p): if key != 'global': cl, icl = key[0], key[1] if icl == 1: rate_tr_1.append(p[(cl, icl)]) else: rate_tr_2.append(p[(cl, icl)]) plt.figtext( pos_x, pos_y_ini - 1 * pas, 'Global : %.1f$\pm$%.1f%%' % (np.mean(rate_tr), np.std(rate_tr))) plt.figtext( pos_x, pos_y_ini - 2 * pas, '%s (%d) : %.1f$\pm$%.1f%%' % (types[0], 0, np.mean(rate_tr_1), np.std(rate_tr_1))) plt.figtext( pos_x, pos_y_ini - 3 * pas, '%s (%d) : %.1f$\pm$%.1f%%' % (types[1], 1, np.mean(rate_tr_2), np.std(rate_tr_2))) pos_y_ini = pos_y_ini - 4.5 * pas pas = .025 plt.figtext(pos_x, pos_y_ini, 'Test set %s' % method) rate_test, rate_test_1, rate_test_2 = [], [], [] for draw in sorted(dic): p = dic[draw]['out']['rate_test'] rate_test.append(p['global']) for key in sorted(p): if key != 'global': cl, icl = key[0], key[1] if icl == 1: rate_test_1.append(p[(cl, icl)]) else: rate_test_2.append(p[(cl, icl)]) plt.figtext( pos_x, pos_y_ini - 1 * pas, 'Global : %.1f$\pm$%.1f%%' % (np.mean(rate_test), np.std(rate_test))) plt.figtext( pos_x, pos_y_ini - 2 * pas, '%s (%d) : %.1f$\pm$%.1f%%' % (types[0], 0, np.mean(rate_test_1), np.std(rate_test_1))) plt.figtext( pos_x, pos_y_ini - 3 * pas, '%s (%d) : %.1f$\pm$%.1f%%' % (types[1], 1, np.mean(rate_test_2), np.std(rate_test_2)))
def test_type3_font(): plt.figtext(.5, .5, "I/J")
print('dissimilarity : ', dissimilarity) print('similarity_loss : ', similarity_loss) dist = cdist(model_lf, model_rg, 'cosine') print('Pairwise distance : ', dist) euc = np.linalg.norm(model_lf - model_rg) print('euc : ', euc) fig = plt.figure() plt.title(('Similarity: %f, Dissimilarity: %f\nEuclidean Dist: %f, Logits: %f' % (similarity, dissimilarity, euc, my_logits)), loc='center') if my_logits > 0.0: textstr = 'Similar' props = dict(boxstyle='round', facecolor='green', alpha=0.5) fig_txt = tw.fill(tw.dedent(textstr), width=80) plt.figtext(0.51, 0.05, fig_txt, horizontalalignment='center', fontsize=12, multialignment='center', bbox=dict(boxstyle="round", facecolor='green', ec="0.5", pad=0.5, alpha=1), fontweight='bold') else: textstr = 'Dissimilar' props = dict(boxstyle='round', facecolor='red', alpha=0.5) fig_txt = tw.fill(tw.dedent(textstr), width=80) plt.figtext(0.51, 0.05, fig_txt, horizontalalignment='center', fontsize=12, multialignment='center', bbox=dict(boxstyle="round", facecolor='red', ec="0.5", pad=0.5, alpha=1), fontweight='bold') plt.axis('off') ax1 = fig.add_subplot(1, 2, 1) l_im = np.array(img)[0]
midpoint_errors_before, data_colors[date_list_before[0]], data_error_colors[date_list_before[0]], 'Before baking') print(residual_std_after) print(residual_std_before) residual_percentages(ax_sub, temps_shifted_after, fit_parameters_after[0], midpoints_after, data_colors[date_list_after[0]], data_error_colors[date_list_after[0]], 'After baking') residual_percentages(ax_sub, temps_shifted_before, fit_parameters_before[0], midpoints_before, data_colors[date_list_before[0]], data_error_colors[date_list_before[0]], 'Before baking') # Setting the positions of the text on the figure if not plot_ratios: plt.figtext(0.75, 0.55, txt_str_after, color=data_colors[date_list_after[0]], fontsize=10) plt.figtext(0.75, 0.35, txt_str_before, color=data_colors[date_list_before[0]], fontsize=10) if plot_ratios: ax_ratio = ax_data.twinx() ax_ratio.set_position((0.08, 0.4, 0.6, 0.5)) ax_ratio.tick_params(axis='y', colors='green') axes = [ax_data, ax_sub, ax_ratio]
random_seed = 6 sample_fraction = 0.1 sample_df = no2_df.sample(frac=sample_fraction, axis="columns", random_state=random_seed) sample_df.reset_index(inplace=True) sample_df.MeasurementDateGMT = pd.to_datetime(sample_df.MeasurementDateGMT) fig, ax = plt.subplots(figsize=(20, 8)) fig.suptitle(r"LAQN sample - NO$_2$") for column in sample_df.iloc[:, 1:].columns: print(f"Plotting {column}...") ax.plot(sample_df.MeasurementDateGMT, sample_df[column], label=column, alpha=0.3) plt.figtext( 0.2, 0.8, f"Sampling {int(sample_fraction*100)}% of all sites with random seed ({random_seed})" ) ax.set(xlabel="Time", ylabel=r"NO$_2$ ($\mu$g m$^{-3}$)") ax.legend(loc="upper right") # plt.show() plot_filename = os.path.join(os.path.dirname(os.path.realpath(__file__)), f"LAQN_NO2_sample_seed{random_seed}.png") fig.savefig(plot_filename) print(f"\nSaved plot to:\n{plot_filename}")
def display_rates(plt, out, out_comp=None, map_nl=None): """ Display success rates in the top right corner. """ method = out['method'] rate = out['rate_test'] NB_class = len(rate) - 1 if not (out_comp and map_nl): pos_y_ini = .95 pas = .025 plt.figtext(.78, pos_y_ini, 'Test set %s' % method.upper()) for key in sorted(rate): if key != 'global': cl, icl = key[0], key[1] plt.figtext(.78, pos_y_ini - (icl + 1) * pas, '%s (%d) : %.1f%%' % (cl, icl, rate[(cl, icl)])) if out_comp or map_nl: if out_comp: sup = out_comp elif map_nl: sup = map_nl pos_y = pos_y_ini - .04 plt.figtext(.78, pos_y - NB_class * pas, 'Test set %s' % sup['method'].upper()) p = sup['rate_test'] for key in sorted(p): if key != 'global': cl, icl = key[0], key[1] plt.figtext(.78, pos_y - NB_class * pas - (icl + 1) * pas, '%s (%d) : %.1f%%' % (cl, icl, p[(cl, icl)])) if out_comp and map_nl: if NB_class == 2: pos_y_ini = .95 pas = .02 else: pos_y_ini = .96 pas = .015 s = 10 plt.figtext(.78, pos_y_ini, 'Test set %s' % method.upper(), size=s + 1) for key in sorted(rate): if key != 'global': cl, icl = key[0], key[1] plt.figtext(.78, pos_y_ini - (icl + 1) * pas, '%s (%d) : %.1f%%' % (cl, icl, rate[(cl, icl)]), size=s) pos_y = pos_y_ini - .03 pos_y_ini = pos_y - NB_class * pas plt.figtext(.78, pos_y_ini, 'Test set %s' % out_comp['method'].upper(), size=s + 1) p = out_comp['rate_test'] for key in sorted(p): if key != 'global': cl, icl = key[0], key[1] plt.figtext(.78, pos_y_ini - (icl + 1) * pas, '%s (%d) : %.1f%%' % (cl, icl, p[(cl, icl)]), size=s) pos_y = pos_y_ini - .03 pos_y_ini = pos_y - NB_class * pas plt.figtext(.78, pos_y_ini, 'Test set %s' % map_nl['method'].upper(), size=s + 1) p = map_nl['rate_test'] for key in sorted(p): if key != 'global': cl, icl = key[0], key[1] plt.figtext(.78, pos_y_ini - (icl + 1) * pas, '%s (%d) : %.1f%%' % (cl, icl, p[(cl, icl)]), size=s)
def plot_RAO_1d(s, omegas, wave_direction, waterdepth=0): """Calculates and plots the RAOs. Call plt.show afterwards to show the plots""" RAOs = RAO_1d(s=s, omegas=omegas, wave_direction=wave_direction, waterdepth=waterdepth) # now plot # Use one figure per node nodes = s.dynamics_nodes() modes = s.dynamics_modes() figures = dict() # loop over nodes and modes and attach a figure to each of the nodes for i in range(len(nodes)): node = nodes[i] node_name = node.name if node_name in figures.keys(): figure = figures[node_name] else: figure = list() figure.append(i) figures[node_name] = figure mode_names = ['X', 'Y', 'Z', 'RX', 'RY', 'RZ'] import matplotlib.pyplot as plt from matplotlib.figure import figaspect for figure in figures.values(): n_plots = len(figure) n_h = 1 n_v = 1 w, h = figaspect(1) if n_plots > 1: n_h = 2 # horizontal n_v = 1 w, h = figaspect(0.5) if n_plots > 2: n_h = 2 # horizontal n_v = 2 w, h = figaspect(1) if n_plots > 4: n_h = 2 # horizontal n_v = 3 w, h = figaspect(1.5) f = plt.figure(figsize=(w, h)) for i_plot, i_entry in enumerate(figure): ax1 = plt.subplot(n_v, n_h, i_plot + 1) node = nodes[i_entry] mode = modes[i_entry] a = RAOs[i_entry, :] amplitude = np.abs(a) if mode > 2: amplitude = np.rad2deg(amplitude) ax1.plot(omegas, amplitude, label="amplitude", color='black', linewidth=1) plt.title(mode_names[mode]) ax1.set_xlabel('omega [rad/s]') plt.grid() yy = plt.ylim() if yy[1] < 1e-4: plt.ylim((0, 1)) continue elif yy[1] < 1.0: plt.ylim((0, 1)) else: plt.ylim((0, yy[1])) xx = plt.xlim() # force min x to 0 plt.ylim((0, xx[1])) ax2 = ax1.twinx() ax2.plot(omegas, np.angle(a), label="phase", color='black', linestyle=':', linewidth=1) plt.suptitle('{}\nIncoming wave direction = {}'.format( node.name, wave_direction)) plt.figtext( 0.995, 0.01, 'Amplitude (solid) in [m] or [deg] on left axis\nPhase (dashed) in [rad] on right axis', ha='right', va='bottom', fontsize=6) plt.tight_layout()
#ax.plot( range(valid_freq, len(train_history)+valid_freq, valid_freq), valid_history['loss'].tolist(), label='valid loss', color='Red') #marker='o', markersize=5, #plt.axis([0, len(train_history), 0, 1.5]) ax.set_xlim([0, len(train_history)]) ax.set_ylim([-0.05,0.2]) ax.yaxis.set_minor_locator(ticker.MultipleLocator(0.005)) #ax.xaxis.set_major_locator(ticker.MultipleLocator(5)) plt.title('Loss graph', fontsize=15) plt.xlabel('epoch', fontsize=13) plt.ylabel('loss', fontsize=13) box = ax.get_position() ax.set_position([box.x0, box.y0, box.width*0.7, box.height]) plt.legend(fontsize=12, bbox_to_anchor=(1.05,1),loc=2) plt.figtext(0.7, 0.7, 'accuracy: '+str(test_accuracy[-1])) plt.figtext(0.7, 0.6, 'frozen at '+str(frozen_epoch)) plt.savefig(os.path.join(save_path, model_name, str(len(train_history))+'epochs_tvloss.png')) print("Figure saved: "+os.path.join(save_path, model_name, str(len(train_history))+'epochs_tvloss.png')) #plt.close() plt.figure(figsize=(8,6)) ax = plt.subplot(111) ax.plot(train_history['err'].tolist(), label='train err') #ax.plot( range(valid_freq, len(train_history)+valid_freq, valid_freq), valid_history['err'].tolist(), label='valid err', color='Red') #marker='o', markersize=5 #plt.axis([0, len(train_history), 0, 1.5]) ax.set_xlim([0, len(train_history)])