def home(request): import matplotlib.pyplot as plt, mpld3 # Graph fig = plt.figure() x = [4, 12, 14, 4, 22, 18] y = [3, 10, 16, 3, 20, 17] plt.plot([1, 2, 3, 4], [1, 4, 9, 16], mec='w', mew=5, ms=20) graph1 = mpld3.fig_to_html(fig) # Graph 2 fig = plt.figure() plt.plot([1, 2, 3, 4], [1, 4, 9, 16], 'ro') graph2 = mpld3.fig_to_html(fig) # Histogram fig = plt.figure() ax = fig.add_subplot(111, axisbg='#EEEEEE') ax.grid(color='white', linestyle='solid') x = np.random.normal(size=1000) ax.hist(x, 30, histtype='stepfilled', fc='lightblue', alpha=0.5); histogram = mpld3.fig_to_html(fig) return render_to_response('election_prediction_site/index.html', {'graph1': graph1, 'graph2': graph2, 'histogram': histogram})
def show_d3(figure=None): """ Show matplotlib fig using d3.js. """ if figure: img = mpld3.fig_to_html(figure, d3_url=D3_URL) else: img = mpld3.fig_to_html(fig, d3_url=D3_URL) dat = img.replace('\n', '\r') print 'embed:', dat
def render_webfigure(var_dict): userlon = float(var_dict['userlon']) userlat = float(var_dict['userlat']) data = var_dict['data'] fig, ax = plt.subplots(figsize=(15,10)) #return antlons, antlats, scss, cats, separations, geodesics, contour_lons, contour_lats antlons = data[0] antlats = data[1] scss = data[2] cats = data[3] contour_lons = data[6] contour_lats = data[7] #print userlon plt.plot(userlon, userlat, 'g*', ms=40) plt.scatter(antlons, antlats, c='r') for i in xrange(len(antlons)): label = '{} ({})'.format(scss[i], cats[i]) plt.text(antlons[i]+.05, antlats[i], label) plt.plot(contour_lons[i], contour_lats[i]) #print contour_lons[i], contour_lats[i] import json execfile("/Users/mwoods/Work/OldJobs/JobSearch/Pre-Insight/plotUSA.py") jdata = json.load(open("/Users/mwoods/Work/OldJobs/JobSearch/Pre-Insight/states.json")) i=0 for state in jdata['geometries']: i+=1 j=0 # State only has one border, do not enter into 'for each border' loop. if len(state['coordinates'][0]) != 1: x,y = np.array(state['coordinates']).T plt.plot(x,y, 'b', lw=3) continue # There is a list with multiple borders (islands) for shape in state['coordinates']: x,y = np.array(shape[0]).T plt.plot(x,y, 'b', lw=3) plt.xlim(userlon-1, userlon+1) plt.ylim(userlat-1, userlat+1) plt.xlabel("Longitude") plt.ylabel("Latitude") #plt.gca().set_aspect('equal') #plt.hist(np.random.random(100)) #plt.scatter(np.random.random(100), np.random.random(100)) fig_html = mpld3.fig_to_html(fig) return mpld3.fig_to_html(fig)
def d3(): rtimes, rt, rp = np.loadtxt("data/data.txt").T mask = np.logical_and(rtimes>1391000000, rtimes<1393000000) rtimes = rtimes[mask] rt = rt[mask] rtimes = map(datetime.datetime.fromtimestamp, rtimes) rtimes = matplotlib.dates.date2num(rtimes) fig, axis = plt.subplots() axis.xaxis_date() fig.autofmt_xdate() axis.plot_date(rtimes, rt, "-",linewidth=3, color="black") forecast_list = [] for fname in glob.glob("data/forecast.1391*.txt"): stamp = fname.split(".")[1] times, tempa = np.loadtxt(fname).T times = map(datetime.datetime.fromtimestamp, times) times = matplotlib.dates.date2num(times) points = np.array([times, tempa]).T.reshape(-1, 1, 2) segments = np.concatenate([points[:-1], points[1:]], axis=1) lc = LineCollection(segments, cmap=plt.get_cmap("jet"), norm=plt.Normalize(0, 1)) lc.set_array(np.linspace(0,1,len(times))) lc.set_linewidth(1) axis.add_collection(lc) axis.plot_date(times, tempa, "-", linewidth=2) return fig_to_html(fig)
def csuppfb(): if request.args['df'] : dataf1 =request.args['df'] dataf = pd.read_csv(app.config['UPLOAD_FOLDER']+'/'+dataf1) index_list=["Case Owner","Case Number","Support Survey - Service rating","Support Survey - Service feedback"] value_list = ["Age (Hours)"] pvt = pd.pivot_table(dataf, index=index_list, values=value_list, aggfunc=[np.sum, np.mean, np.std], fill_value=0, columns=None) agent_df = [] for agent in pvt.index.get_level_values(0).unique(): agent_df.append([agent, pvt.xs(agent, level=0).to_html()]) env = Environment(loader=FileSystemLoader('.')) template = env.get_template("csupp.html") plt=mpld3.fig_to_html(pvt) template_vars={"title": "CSUPP FB REPORT", "Excellent": get_summary_stats(dataf,"Excellent"), "Good": get_summary_stats(dataf,"Good"), "csupp_pivot_table": pvt.to_html(), "agent_detail": agent_df, "csupp_pivot_graph": plt.to_html()} html_out = template.render(template_vars) return html_out
def salaries_stats_regression_plot(self): """ This function is to plot the regression results. Note: By calling this function, you will get a scatter plot on predicted salaries (y axis) and true salaries (x axis). Return: html: a string of html of regression plot. """ regdata = self.df.reset_index(1) regdata = regdata[regdata['POS'].isin(['C','SF','PF','PG','SG'])] pos={'C':2,'PF':3,'PG':4,'SF':5,'SG':1} posdata = [pos[regdata['POS'][j]] for j in xrange(0,len(regdata.index))] #convert position information into categorical numbers fig, ax = plt.subplots(subplot_kw=dict(axisbg='#EEEEEE'), figsize=(10,6)) scatter = ax.scatter(regdata['SALARY'], regdata['Predicted'], c=posdata, s=10*regdata['PPG'], color=['skyblue', 'yellowgreen', 'lightcoral', 'mediumpurple','gold']) ax.grid(color='white', linestyle='solid') labels = [regdata.index[i] for i in xrange(0,len(regdata.index))]#add player names as labels tooltip = mpld3.plugins.PointLabelTooltip(scatter, labels=labels) mpld3.plugins.connect(fig, tooltip) reference = np.arange(self.df['SALARY'].min(),self.df['SALARY'].max(),1000) plt.plot(reference,reference,'white',alpha=0.7) #a reference line y = x #set x and y axis labels and their locations to avoid overlapping with x and y axis ticks ax.set_xlabel('True Salaries', fontsize=16) ax.set_ylabel('Predicted Salaries', fontsize=16) ax.xaxis.set_label_coords(0.5,-0.08) ax.yaxis.set_label_coords(-0.14,0.5) html = mpld3.fig_to_html(fig) plt.close() return html
def generate_histogram(dates, values): """ Generate a barchart from the given information. This function receives a list of floats and a list of labels and uses them to generates a barchart histogram. Keyword arguments: values -- a list of values for each bar of the chart. labels -- a list of labels for each bar of the chart. """ #n_groups = len(values) fig, axes = plt.subplots() axes.plot(dates, values, 'o--') plt.ylim([0, 5]) one_mon_rel = relativedelta(months=1) plt.xlim([min(dates), max(dates) + one_mon_rel]) fig.set_size_inches(12, 5) plt.xlabel('Videos through time') plt.ylabel('Mean video scores') plt.title('Channel\'s video progress through time') plt.legend() plt.tight_layout() return mpld3.fig_to_html(fig)
def plot(self, data, notebook=False, show=True, savename=None): fig = pyplot.figure() ncenters = len(self.centers) colorizer = Colorize() colorizer.get = lambda x: self.colors[int(self.predict(x)[0])] # plot time series of each center # TODO move into a time series plotting function in viz.plots for i, center in enumerate(self.centers): ax = pyplot.subplot2grid((ncenters, 3), (i, 0)) ax.plot(center, color=self.colors[i], linewidth=5) fig.add_axes(ax) # make a scatter plot of the data ax2 = pyplot.subplot2grid((ncenters, 3), (0, 1), rowspan=ncenters, colspan=2) ax2, h2 = scatter(data, colormap=colorizer, ax=ax2) fig.add_axes(ax2) plugins.connect(fig, HiddenAxes()) if show and notebook is False: mpld3.show() if savename is not None: mpld3.save_html(fig, savename) elif show is False: return mpld3.fig_to_html(fig)
def plot_weight_distributions(self, simulation): # Plot weight distribution at given intervals. plots = [] for n in simulation['neurons']: frame = 1 frames = 5 rows = frames + 1 cols = 1 f = pylab.figure() for dist in n['weight_distributions']: # Plot a histogram of the values. p = pylab.subplot(rows, cols, frame) # Only add title to first plot. if frame == 1: pylab.title('Weight Distribution Over Time') p.axes.get_xaxis().set_visible(False) p.axes.get_yaxis().set_ticks([]) p.bar(np.arange(0, 1, 0.1), dist, 0.1) # Only show if plot is complete. if rows * cols == frame: pylab.xlabel("Weight Value") p.axes.get_xaxis().set_visible(True) frame += 1 plots.append(mpld3.fig_to_html(f)) pylab.close(f) return plots
def mpld3_to_html(self): """This require to call a plotting figure before hand""" from gdsctools import gdsctools_data # This copy the full path and therefore HTML cannot # be moved in another directory. to be fixed. js_path1 = gdsctools_data('d3.v3.min.js', where='javascript') js_path2 = gdsctools_data('mpld3.v0.2.js', where='javascript') try: # mpld3 is great but there are a couple of issues # 1 - legend zorder is not used so dots may be below the legend, # hence we set the framealpha =0.5 # 2 - % character even though there well interpreted in matploltib # using \%, they are not once parsed by mpld3. So, here # we remove the \ character axl = pylab.legend(loc='best', framealpha=0.8, borderpad=1) axl.set_zorder(10) # in case there is a circle behind the legend. texts = [this.get_text() for this in axl.get_texts()] for i, text in enumerate(texts): text = text.replace("\\%", "%") text += " " axl.get_texts()[i].set_text(text) import mpld3 htmljs = mpld3.fig_to_html(self.current_fig, d3_url=js_path1, mpld3_url=js_path2) except: htmljs = "" return """<div class="jsimage"> """ + htmljs + "</div>"
def to_html(self): import matplotlib.pyplot as plt html = fig_to_html(self.content, figid="generatedchart") #closes fig element (refresh) plt.close() return html
def display_figure(fig, message=None, max_width='100%'): "Display widgets applicable to the specified element" if OutputMagic.options['fig'] == 'repr': return None figure_format = OutputMagic.options['fig'] dpi = OutputMagic.options['dpi'] backend = OutputMagic.options['backend'] if backend == 'nbagg' and new_figure_manager_given_figure is not None: manager = new_figure_manager_given_figure(OutputMagic.nbagg_counter, fig) # Need to call mouse_init on each 3D axis to enable rotation support for ax in fig.get_axes(): if isinstance(ax, Axes3D): ax.mouse_init() OutputMagic.nbagg_counter += 1 manager.show() return '' elif backend == 'd3' and mpld3: fig.dpi = dpi mpld3.plugins.connect(fig, mpld3.plugins.MousePosition(fontsize=14)) html = "<center>" + mpld3.fig_to_html(fig) + "<center/>" else: renderer = Store.renderer.instance(dpi=dpi) figdata = renderer.figure_data(fig, figure_format) if figure_format=='svg': figdata = figdata.encode("utf-8") b64 = base64.b64encode(figdata).decode("utf-8") (mime_type, tag) = MIME_TYPES[figure_format], HTML_TAGS[figure_format] src = HTML_TAGS['base64'].format(mime_type=mime_type, b64=b64) html = tag.format(src=src) plt.close(fig) return html if (message is None) else '<b>%s</b></br>%s' % (message, html)
def get_heatmap(ds): plt.close('all') corrmat = ds.corr() fig, ax = plt.subplots() sns.heatmap(corrmat, vmax=.8, square=True) heatmap_html = mpld3.fig_to_html(fig) return heatmap_html
def plot(groups,fig,ax,cluster_names,cluster_colors): for name, group in groups: points = ax.plot(group.x, group.y, marker='o', linestyle='', ms=10, label=cluster_names[name], mec='none', color=cluster_colors[name]) ax.set_aspect('auto') labels = [i for i in group.title] #set tooltip using points, labels and the already defined 'css' tooltip = mpld3.plugins.PointHTMLTooltip(points[0], labels, voffset=5, hoffset=5, css=css) #connect tooltip to fig mpld3.plugins.connect(fig, tooltip, TopToolbar()) #set tick marks as blank ax.axes.get_xaxis().set_ticks([]) ax.axes.get_yaxis().set_ticks([]) #set axis as blank ax.axes.get_xaxis().set_visible(False) ax.axes.get_yaxis().set_visible(False) ax.legend(numpoints=1) #show legend with only one dot file_ = open('clustering.html', 'w') file_.write(mpld3.fig_to_html(fig)) file_.close() # mpld3.show() #show the plot
def draw_fig(fig_type): """Returns html equivalent of matplotlib figure Parameters ---------- fig_type: string, type of figure one of following: * line * bar Returns -------- d3 representation of figure """ with lock: fig, ax = plt.subplots() if fig_type == "line": ax.plot(x, y) elif fig_type == "bar": ax.bar(x, y) elif fig_type == "pie": ax.pie(pie_fracs, labels=pie_labels) elif fig_type == "scatter": ax.scatter(x, y) elif fig_type == "hist": ax.hist(y, 10, normed=1) elif fig_type == "area": ax.plot(x, y) ax.fill_between(x, 0, y, alpha=0.2) return mpld3.fig_to_html(fig)
def pos_salaries_distribution(self): """ This is a function to analyze and plot salaries distribution by positions. Return: html: a string of html of by-position salaries distribution plot. pos: a dataframe with salaries statistics by positions. """ salaries_pos_year = self.df[[self.year,'POS']].dropna() positions = ['C','PF','SF','SG','PG'] salaries_pos_year = salaries_pos_year[salaries_pos_year['POS'].isin(positions)] pos = [salaries_pos_year[salaries_pos_year['POS'] == position].describe().rename(columns={self.year:position}) for position in positions] #store by-position salaries statistics into a list pos = pd.concat(pos, axis=1) #merge all by-position dataframes #convert all elements in dataframe into integers for position in positions: pos[position] = pos[position].apply(lambda x: int(x)) ax = salaries_pos_year.boxplot(by='POS',sym='r*',figsize=(10,6)) ax.set_axis_bgcolor('#EEEEEE') ax.grid(color='white', linestyle='solid') #add positions name text into the boxplot loc = salaries_pos_year.groupby('POS').median() for i in xrange(0,5): ax.text(i+1, loc[self.year][i], loc.index[i], ha='center', va='bottom') plt.title('') ax.set_xlabel('Positions', fontsize=16) fig = ax.get_figure() html = mpld3.fig_to_html(fig) plt.close() return html, pos
def save_and_or_show_plot(show=None, savefig="None", **kwargs): """ Save and/or show current matplotlib figure Parameters ---------- show: bool or None Show plot, when None only show when savefig is not used default: None savefig: string path to output file of figure. If extension is html, mpld3 will be used to generate a d3 backed html output. \*\*kwargs: keyword arguments passed on to ``matplotlib.pyplot.savefig`` """ if savefig is not None and savefig != "None": if savefig.endswith(".html"): # Export using mpld3 import mpld3 open(savefig, "wt").write(mpld3.fig_to_html(plt.gcf())) else: plt.savefig(savefig, **kwargs) if show is None: show = False else: if show is None: show = True if show: plt.show()
def plot_to_html( name = None ): """Converts a matplotlib figure, such that it can be displayed in an html page either using an embedded svg tag (default) or by using mpld3 """ result = "" if mpld3_available and use_mpld3 : html = mpld3.fig_to_html( plt.gcf() ) result = html else: figStr = io.StringIO() plt.savefig( figStr, format='svg', bbox_inches='tight' ) result = figStr.getvalue() if write_pdfs and name: if not os.path.exists(pdf_output_dir): os.makedirs(pdf_output_dir) filename = os.path.join(pdf_output_dir, name + '.pdf') filepath = os.path.join(filename) plt.savefig( filepath, bbox_inches='tight' ) result = '<a href="%s" > %s </a>' % ( filename, result ) plt.clf() return result
def overall_salaries_trend(self): """ This function is to analyze and plot nba salaries trend. Return: html: a string of html for the salaries trend plot. salaries: a dataframe with salaries statistical information (e.g., mean, min, max) in each year. """ years = xrange(2000,2016) salaries = [self.df[year].describe().apply(lambda x: int(x)) for year in years] #store salaries statistical information for each year in a list salaries = pd.concat(salaries, axis=1).T.drop(['25%','75%'],1) #merge all salaries statistical information dataframes into a dataframe fig = plt.figure(figsize=(10,6)) ax = fig.add_subplot(111, axisbg='#EEEEEE') ax.grid(color='white', linestyle='solid') ave_salaries = self.df.mean() #calculate the average salaries for each year plt.bar(self.df.columns, ave_salaries, 0.5, color='#0077FF', alpha=0.5) ax.set_xlabel('Year', fontsize=16) ax.set_ylabel('Average Salaries', fontsize=16) ax.xaxis.set_label_coords(0.5,-0.08) ax.yaxis.set_label_coords(-0.14,0.5) plt.title('2000-2015 NBA Average Salaries Trend') html = mpld3.fig_to_html(fig) plt.close() return html, salaries
def renderFigure(self, fig): def genMarkup(chartFigure): return self.env.from_string(""" {0} {{%for message in messages%}} <div>{{{{message}}}}</div> {{%endfor%}} """.format(chartFigure) ).render(messages=self.messages) if not self.useMpld3: import base64 try: from io import BytesIO as pngIO except ImportError: from StringIO import StringIO as pngIO png=pngIO() plt.savefig(png, pad_inches=0.05, bbox_inches='tight', dpi=self.getDPI()) try: return( genMarkup(""" <center><img style="max-width:initial !important" src="data:image/png;base64,{0}" class="pd_save"></center> """.format(base64.b64encode(png.getvalue()).decode("ascii")) ) ) finally: png.close() else: mpld3.enable_notebook() try: return genMarkup(mpld3.fig_to_html(fig)) finally: mpld3.disable_notebook()
def run(data): global t0, lines, test print data #override t to be count of seconds t=time.time()-t0 tdata.append(t) for sensor in all_data: for axis in all_data[sensor]: if axis=="x":i=0 if axis=="y":i=1 if axis=="z":i=2 # if test==0: print sensor+" ("+axis+")" all_data[sensor][axis].append(data[sensor][i]) lines[sensor][axis][0].set_data(tdata, all_data[sensor][axis]) # all_lines=[[axis for axis in sensor.values()] for sensor in lines.values()] # test=1 #MOVING WINDOW xmin, xmax = ax[0].get_xlim() if t >= xmax-1: #once the line get's 9 10ths of the way... #move the window by 5 seconds forward xmin+=5 xmax+=5 for i in range(len(axes)): ax[i].set_xlim(xmin, xmax) # print 'test' ax[0].figure.canvas.draw() ax[1].figure.canvas.draw() ax[2].figure.canvas.draw() html=mpld3.fig_to_html(fig) print html # mpld3.show(fig) return html
def display_frame(plot, figure_format, backend, dpi, css, message, **kwargs): """ Display specified element as a figure. Note the plot instance needs to be initialized appropriately first. """ if backend == 'nbagg': manager = plot.renderer.get_figure_manager(OutputMagic.nbagg_counter, plot) if manager is None: return '' OutputMagic.nbagg_counter += 1 manager.show() return '' elif backend == 'd3' and mpld3: plot.state.dpi = dpi mpld3.plugins.connect(plot.state, mpld3.plugins.MousePosition(fontsize=14)) html = "<center>" + mpld3.fig_to_html(plot.state) + "<center/>" else: renderer = plot.renderer.instance(dpi=dpi) figdata = renderer.figure_data(plot, figure_format) w,h = renderer.get_size(plot) if figure_format=='svg': figdata = figdata.encode("utf-8") if figure_format == 'pdf' and 'height' not in css: css['height'] = '%dpx' % (h*dpi*1.15) b64 = base64.b64encode(figdata).decode("utf-8") (mime_type, tag) = MIME_TYPES[figure_format], HTML_TAGS[figure_format] src = HTML_TAGS['base64'].format(mime_type=mime_type, b64=b64) html = tag.format(src=src, css=dict_to_css(css)) return html if (message is None) else '<b>%s</b></br>%s' % (message, html)
def draw(self, name=None, old=None, new=None): if name is not None and self.DONT_DRAW.match(name): return if self._FREEZE: return plot_and_message = '' # Better way would be a decorator or something that only goes into draw if not autoupdate if self.autoupdate: # Generate new figure object f = plt.figure(figsize=(self.figwidth, self.figheight)) if PLOTPARSER.is_3d(self.kind): projection = '3d' else: projection = None ax = f.add_subplot(111, projection=projection) if self._color_state or self.kind not in ['spec', 'waterfall', 'contour', 'contour3d']: colorkwags = dict(color=self.color) else: colorkwags = dict(cmap=self.colormap, cbar=self.colorbar) self.spec_modified.plot(ax=ax, fig=f, kind=self.kind, norm=self.NORMUNITS_REV[self.norm_unit], **colorkwags ) f.tight_layout() #Padding around plot lines = ax.get_lines() plt.close(f) #http://mpld3.github.io/modules/API.html if self.interactive: import mpld3 if self.selectlines: from line_plugin import HighlightLines for idx, col in enumerate(self.spec_modified.columns): name = 'COLUMN(%s): %s' % (idx, col) tooltip = mpld3.plugins.LineLabelTooltip(lines[idx], name) #voffset=10, hoffset=10, css=css) mpld3.plugins.connect(f, tooltip) mpld3.plugins.connect(f, HighlightLines(lines)) plot_and_message += mpld3.fig_to_html(f) else: plot_and_message += mpl2html(f) self.fig_old = f else: plot_and_message += html_figure(self.fig_old) # VALUE IS WHAT GUI LOOKS UP!!! self.value = plot_and_message
def get_graph(): import matplotlib.pyplot as plt, mpld3 fig = plt.figure() x= y= z = np.arange(10) plt.plot(x) html_str = mpld3.fig_to_html(fig) return html_str
def map_plot(): import matplotlib.pyplot as plt, mpld3 import numpy as np from mpl_toolkits.basemap import Basemap fig, ax = plt.subplots() m = Basemap() #m = Basemap(projection='ortho',lat_0=0,lon_0=0,resolution='l') #m = Basemap(projection='moll',lon_0=0,resolution='l') # Shift 'lon' from [0,360] to [-180,180], make numpy array #tmp_lon = np.array([lon[n]-360 if l>=180 else lon[n] # for n,l in enumerate(lon)]) # => [0,180]U[-180,2.5] #i_east, = np.where(tmp_lon>=0) # indices of east lon #i_west, = np.where(tmp_lon<0) # indices of west lon #lon = np.hstack((tmp_lon[i_west], tmp_lon[i_east])) # stack the 2 halves # Correspondingly, shift the 'air' array #tmp_air = np.array(air) #air = np.hstack((tmp_air[:,i_west], tmp_air[:,i_east])) #poly_paths = m.drawcoastlines().get_paths() # coastline polygon paths #X,Y = np.meshgrid(lon,lat) m.etopo() #m.contourf(X, Y, air, 40, alpha=.75, cmap='jet') #ticks=range(-90,90,30) #ax.set_yticks(ticks) #ax.set_ylabel("Latitude", fontsize=16) #ax.set_xlabel("Longitude", fontsize=16) #plt.colorbar() # D3 Works! #mpld3.display(fig) return mpld3.fig_to_html(fig,template_type="general")
def plot(self, notebook=False, colormap='polar', scale=1, maptype='points', show=True, savename=None): # make a spatial map based on the scores fig = pyplot.figure(figsize=(12, 5)) ax1 = pyplot.subplot2grid((2, 3), (0, 1), colspan=2, rowspan=2) if maptype is 'points': ax1, h1 = pointmap(self.scores, colormap=colormap, scale=scale, ax=ax1) elif maptype is 'image': ax1, h1 = imagemap(self.scores, colormap=colormap, scale=scale, ax=ax1) fig.add_axes(ax1) # make a scatter plot of sampled scores ax2 = pyplot.subplot2grid((2, 3), (1, 0)) ax2, h2, samples = scatter(self.scores, colormap=colormap, scale=scale, thresh=0.01, nsamples=1000, ax=ax2, store=True) fig.add_axes(ax2) # make the line plot of reconstructions from principal components for the same samples ax3 = pyplot.subplot2grid((2, 3), (0, 0)) ax3, h3, linedata = tsrecon(self.comps, samples, ax=ax3) plugins.connect(fig, LinkedView(h2, h3[0], linedata)) plugins.connect(fig, HiddenAxes()) if show and notebook is False: mpld3.show() if savename is not None: mpld3.save_html(fig, savename) elif show is False: return mpld3.fig_to_html(fig)
def simple_plot(): import matplotlib matplotlib.use('Agg') import matplotlib.pyplot as plt, mpld3 fig, ax = plt.subplots() plot = ax.plot([3,1,4,1,5], 'ks-', mec='w', mew=5, ms=20) return mpld3.fig_to_html(fig, template_type = "general")
def generate_summary_dict(self, with_html=True): """ This method will allow us to seamlessly conform our regression results into a Django model, making an easy workflow to save results """ try: # from https://github.com/statsmodels/statsmodels/blob/master/statsmodels/regression/linear_model.py#L1999 jb, jbpv, skew, kurtosis = sm.stats.stattools.jarque_bera(self.results.wresid) self.summary_dict = { 'source_file': self.source_file, 'features': ', '.join(self.features), 'target': self.target, 'analysis_type': 'OLS Linear Regression', 'aic': self.results.aic, 'bic': self.results.bic, 'num_observations': self.results.nobs, 'df_residuals': self.results.df_resid, 'r_squared': self.results.rsquared, 'r_squared_adjusted': self.results.rsquared_adj, 'f_statistic': self.results.fvalue, 'jarque_bera': jb, 'jarque_bera_prob': jbpv, 'skew': skew, 'kurtosis': kurtosis, } if with_html: base_summary_html = self.results.summary().as_html() # some styling magic for Bootstrap CSS self.summary_dict['summary_html'] = base_summary_html.replace('simpletable', 'table') fig = self.construct_plot() self.summary_dict['plot_html'] = mpld3.fig_to_html(fig) return self.summary_dict except AttributeError: raise Exception("You must execute `run_ols_regression` method first")
def plot_tweets_histogram(dbname, html_name): """ Function to plot a histogram of tweets as a function of time mentioning Kobe Bryant or Steph Curry """ import numpy as np from datetime import datetime import matplotlib.pyplot as plt import seaborn as sns from mpld3 import fig_to_html df = query_db(dbname) # The start of the game in eastern time gamestart = datetime(2016, 04, 13, 22, 30) df['MinSinceGame'] = (df['CreationTime'] - gamestart) / \ np.timedelta64(60, 's') kobe_list = ['kobe', 'bryant', 'mamba', 'lakers', '60'] kobe_pattern = '|'.join(kobe_list) kobe_idx = df['tweet'].str.contains(kobe_pattern) curry_list = ['steph', 'curry', 'warriors', '73'] curry_pattern = '|'.join(curry_list) curry_idx = df['tweet'].str.contains(curry_pattern) nba_list = ['nba', 'basketball'] nba_pattern = '|'.join(nba_list) nba_idx = df['tweet'].str.contains(nba_pattern) kobe_mention = df['MinSinceGame'][kobe_idx] curry_mention = df['MinSinceGame'][curry_idx] nba_mention = df['MinSinceGame'][nba_idx] fig = plt.figure(figsize=(12, 9)) # We actually will plot the tweets sent out 30 minutes before the game too kobe_mention = kobe_mention[~np.isnan(kobe_mention)] curry_mention = curry_mention[~np.isnan(curry_mention)] nba_mention = nba_mention[~np.isnan(nba_mention)] sns.distplot(kobe_mention[kobe_mention >= -30], kde=False, label='Mention of Kobe Bryant') sns.distplot(curry_mention[curry_mention >= -30], kde=False, label='Mention of Steph Curry') sns.distplot(nba_mention[nba_mention >= -30], kde=False, label='General mention of Basketball') plt.xlabel( 'Number of minutes since start of both games (10:30pm EDT 04/13/2016)', fontsize=18) plt.ylabel('Number of mentions in twitter', fontsize=18) plt.legend(loc=2, framealpha=0, fontsize=14) plt.title('Number of Tweet Mentions Since Start of Both Games', fontsize=24) # In principle I should be able to convert this plot to a bokeh interactive # html, but for some reason bokeh seems to consistently have trouble with # histograms. I would love to figure out how to do it in bokeh later when I # have more time. html = fig_to_html(fig) with open(html_name, 'w') as f: f.write(html)
def get_plot(request, plot, grid, cie31, cie64, labels, norm): start = time.time() log.debug("[%s] Requesting %s/%s/%s/%s/%s/%s - \t\tsID: %s" % (time_now(), plot, grid, cie31, cie64, labels, norm, request.session.session_key)) #Figure fig = plt.figure() #Figure size, in inches, 100 dots-per-inch dpi = 80 fig.set_size_inches(8.0, 4.8) ax = fig.add_subplot(111) plots = request.session['plots'] results = request.session['results'] optionSet = { 'grid' : int(grid), 'cie31' : int(cie31), 'cie64' : int(cie64), 'labels' : int(labels), 'norm' : bool(int(norm)), } updateOptions(optionSet) if plot == 'xyz': webapi.plot.xyz(ax, plots, options) elif plot == 'xy': webapi.plot.xy(ax, plots, options) elif plot == 'lms': webapi.plot.lms(ax, plots, options) elif plot == 'lms_base': webapi.plot.lms_base(ax, plots, options) elif plot == 'bm': webapi.plot.bm(ax, plots, options) elif plot == 'lm': webapi.plot.lm(ax, plots, options) elif plot == 'xyz31': webapi.plot.xyz31(ax, plots, options) elif plot == 'xyz64': webapi.plot.xyz64(ax, plots, options) elif plot == 'xy31': webapi.plot.xy31(ax, plots, options) elif plot == 'xy64': webapi.plot.xy64(ax, plots, options) theFig = mark_safe(mpld3.fig_to_html(fig, template_type='general')) resulting_plot = theFig plt.close(fig) stop = time.time() log.debug("[%s] Plot %s/%s/%s/%s/%s produced in %s seconds - \t\tsID: %s" % ( time_now(), plot, grid, cie31, cie64, labels, str(stop - start), request.session.session_key)) return HttpResponse(resulting_plot);
def banks_problem_analytical_results(r_max, r_min, bailout_cost, discount_rate, nr_of_periods, R): # Bank's problem: # bank's problem at the last stage: max(pi) pi*R(pi)/(1-delta*pi) f_opt_bank_0 = lambda x: -x * (r_min + (r_max - r_min) * (1 - x)) / (1 - discount_rate * x) # Analytical results: # optimal value for period 0 opt_pi_bank = [0] * nr_of_periods v_bank = [0] * nr_of_periods opt_pi_bank[0] = optimize.fmin( f_opt_bank_0, 0.5) # optimization using: Simplex method: the Nelder-Mead v_bank[0] = -f_opt_bank_0(opt_pi_bank[0]) # bank problem in the rest of the periods, eq.(28) f_bank = lambda x, y: -((x * (r_min + (r_max - r_min) * (1 - x)) + (1 - x) * (bailout_cost + discount_rate * y)) / (1 - discount_rate * x)) for k in range(1, nr_of_periods): f_opt_bank_0 = lambda x: f_bank(x, v_bank[k - 1]) opt_pi_bank[k] = optimize.fmin(f_opt_bank_0, 0.7) v_bank[k] = -f_opt_bank_0(opt_pi_bank[k]) # Analytical results: # check that analytical solutions coinside with optimal values: pi_bank_analytical = [0] * nr_of_periods v_bank_analytical = [0] * nr_of_periods temp_v_vheck = [0] * nr_of_periods pi_bank_analytical[0] = (1 - math.sqrt(1 - r_max * discount_rate / (r_max - r_min))) / discount_rate v_bank_analytical[0] = pi_bank_analytical[0] * R( pi_bank_analytical[0]) / (1 - discount_rate * pi_bank_analytical[0]) for i in range(1, nr_of_periods): pi_bank_analytical[i] = (1 - math.sqrt( 1 - discount_rate * (r_max - (bailout_cost + discount_rate * v_bank_analytical[i - 1]) * (1 - discount_rate)) / (r_max - r_min))) / discount_rate v_bank_analytical[i] = ( pi_bank_analytical[i] * R(pi_bank_analytical[i]) + (1 - pi_bank_analytical[i]) * (bailout_cost + discount_rate * v_bank_analytical[i - 1])) / ( 1 - discount_rate * pi_bank_analytical[i]) nr_per = [0] * nr_of_periods for i in range(0, nr_of_periods): nr_per[i] = i # Create plots and pdf file. Save pdf file into graphics folder fig1, ax = pyplot.subplots() ax.plot(nr_per, flipud(opt_pi_bank), label='Machine Results', color='red', linestyle=':') ax.plot(nr_per, flipud(pi_bank_analytical), label='Analytical Results', color='blue', linestyle='--') ax.set_xlabel('Number of Periods') ax.set_ylabel('Probabilities') ax.set_title('Optimal probabilities for the bank') ax.legend(loc='upper left', frameon=0, fontsize='medium', title='', fancybox=True) html_text_fig1 = mpld3.fig_to_html(fig1) pyplot.savefig( 'tbtf/modelfinitebounded/graphics/FB_Optimal_Probabilities_for_the_Bank.pdf', format='pdf') pyplot.close(fig1) return html_text_fig1, opt_pi_bank, pi_bank_analytical
def plot(models): fig, ax = plt.subplots(figsize=(12, 7)) h = [] h = [] models = models.split("+") models_params = {} i = 0 for model_name in models: i += 1 # print model_name models_params[model_name] = '\n'.join([ "%s:\t%s" % (key, val) for key, val in client.get( {"params.model_name": model_name}, collection="Models") ["params"].iteritems() ]) curves = client.get_learning_curves( "" + model_name, val_ref="/mnt/nfs/himl.testing.cs-en.tcs.cs") # startTime=client.get_train_start(model_name) # endTime = client.get_train_end(model_name) #print curves for name, points in curves.iteritems(): if i == 2: p = [datetime.datetime(2017, 10, 2, 12, 15, 40, 27000), 21.56] else: p = [datetime.datetime(2017, 10, 5, 0, 19, 58, 20000), 21.56] points = points[:13] points.insert(0, p) print points # print name #print points[0][0] endTime = None #print endTime if endTime: if points[0][ 0] > endTime: # aby evaluace po konce trenovani byly zarovnane s koncovym casem #points[0][0] = endTime print "HA" curve = [((date - points[0][0]).total_seconds() / 3600.0, score) for date, score in points] c = np.asarray(curve) # print c # print c # fig.autofmt_xdate() # max_idx=np.argmax(c[:,1]) # ax.annotate("test", xy=(c[0],c[1]), xytext=(0, 0),arrowprops=dict(arrowstyle="->")) if i == 2: name = "Adam" else: name = "SGD" p, = plt.plot(c[:, 0], c[:, 1], marker='o', label=name) #p, = plt.plot(c[:, 0], c[:, 1], marker='o', # label=' '.join((model_name, str(max(c[:, 1])), " (", name.split("/")[-1], ")"))) h.append(p) plt.legend( handles=h, loc=3, prop=fontP) # ,bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.) # ax.legend(loc='upper center', bbox_to_anchor=(0.0, -0.05), # fancybox=True, shadow=True) plt.xlabel('Hours') plt.ylabel('BLEU') #plt.ylim([-5,50]) plt.ylim([19, 24]) font = {'family': 'normal', 'weight': 'normal', 'size': 22} #matplotlib.rc('xtick', labelsize=50) #matplotlib.rc('ytick', labelsize=50) matplotlib.rc('font', **font) #plt.rc('legend', fontsize=25) plt.title("Learning curves") plt.savefig("fig.png") #mpld3.show() try: models_params.pop("final_script") models_params.pop("val_script") except: pass figure = mpld3.fig_to_html(fig) #print figure #params=json.dumps(params, indent=4, sort_keys=True) #if type(models)!=list: models=[models] with app.app_context(): #print models return render_template('plot_models.html', figure=figure, models=models_params)
def plot_and_info(model_name): print model_name model = client.get({"params.model_name": model_name}, collection="Models") fig, ax = plt.subplots(figsize=(12, 7)) h = [] params = model["params"] model_name = params["model_name"] #print model_name curves = client.get_learning_curves( "./" + model_name) #,val_ref="/mnt/nfs/himl.testing.cs-en.tcs.cs") #startTime=client.get_train_start(model_name) try: endTime = client.get_train_end(model_name) except: endTime = None #print curves for name, points in curves.iteritems(): #print points #print name #print points[0][0] #print endTime if endTime: if points[0][ 0] > endTime: # aby evaluace po konce trenovani byly zarovnane s koncovym casem points[0][0] = endTime #print "HA" curve = [((date - points[0][0]).total_seconds() / 3600.0, score) for date, score in points] c = np.asarray(curve) #print c # print c # fig.autofmt_xdate() # max_idx=np.argmax(c[:,1]) # ax.annotate("test", xy=(c[0],c[1]), xytext=(0, 0),arrowprops=dict(arrowstyle="->")) lines = plt.plot(c[:, 0], c[:, 1], marker='o', label=' '.join((model_name, str(max(c[:, 1])), " (", name.split("/")[-1], ")"))) print lines mpld3.plugins.connect( fig, mpld3.plugins.PointLabelTooltip(lines[0], labels=c[:, 1].tolist())) h.append(lines[0]) plt.legend( handles=h, loc='lower right', prop=fontP) # ,bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.) # ax.legend(loc='upper center', bbox_to_anchor=(0.0, -0.05), # fancybox=True, shadow=True) plt.xlabel('Hours') plt.ylabel('BLEU') plt.ylim([-5, 50]) plt.title("Learning curves") #plugins.connect(fig, plugins.LineLabelTooltip(lines, c[:, 1].tolist())) #mpld3.show() #plt.savefig("fig.png") try: params.pop("final_script") params.pop("val_script") except: pass try: prev_model = client.db.Models.find({ '_id': { '$lt': model["_id"] } }).sort([('_id', -1)]).limit(1)[0]["params"]["model_name"] except: prev_model = "asd" try: next_model = client.db.Models.find({ '_id': { '$gt': model["_id"] } }).sort([('_id', 1)]).limit(1)[0]["params"]["model_name"] except: next_model = "asd" figure = mpld3.fig_to_html(fig) #print figure print prev_model #params=json.dumps(params, indent=4, sort_keys=True) with app.app_context(): return render_template( 'model_template.html', prev_model=prev_model, next_model=next_model, model_name=model_name, figure=figure, params=model["params"] ) #"<br>".join(["%s:\t%s"%(key, value) for key, value in params.iteritems()]))
def show(name=None): # get selected stock name if request.method == 'POST': name = request.form['stockName'] showPeriod = request.form['showPeriod'] import genIndicator as gi if showPeriod == 'longTerm': # get long term stock data and generate indicators df = gi.getAndGen(name) import constDaytime as cd startShowPoint = cd.startShowing endShowPoint = cd.end else: # get short term intraday data and generate indicators import googleFinanceIntraday as gfi # get 30 days intraday data, periode 60s if name == 'airbus': intradayList = gfi.get_google_finance_intraday('AIR', 60, 30) elif name == 'sopra': intradayList = gfi.get_google_finance_intraday('SOP', 60, 30) elif name == 'biomerieux': intradayList = gfi.get_google_finance_intraday('BIM', 60, 30) elif name == 'oreal': intradayList = gfi.get_google_finance_intraday('OR', 60, 30) elif name == 'total': intradayList = gfi.get_google_finance_intraday('FP', 60, 30) dateList = [] for item in intradayList: dateList.append(item.index[0].strftime( '%d/%m/%Y')) # copy all dates in a list print(item.index[0].strftime('%d/%m/%Y')) seletedDateTimeStr = showPeriod # the date and time selected by user seletedDateTime = datetime.strptime( seletedDateTimeStr, '%d/%m/%Y - %Hh%M') # parse to datetime object seletedDateStr = seletedDateTimeStr[0:10] # seletedTimeStr = seletedDateTimeStr[13:18] # print(seletedDateStr) # print(dateList.index(seletedDateStr)) try: df = intradayList[dateList.index( seletedDateStr )] # target dataframe, because intradayList and dateList have the same index # gi.genAll(df) # generate indicators # print(df['Close']) # set start and end point startShowPoint = df.index[0] # type : timestamp # endShowPoint = seletedDateTime.timestamp() import pandas as pd endShowPoint = pd.Timestamp(seletedDateTime) # print(df.loc[startShowPoint:endShowPoint]) except ValueError: df = "Intraday history no more available.</br>" startShowPoint = 0 # type : timestamp endShowPoint = 0 # read scores from file import readFromFile as rff # print(name) ssList = rff.analyseScoreFile( rff.readScoreFile(name) ) # list of scoreStructure by date, containing tables, date, time and final score intradayTime = [] # list of datetime when give score intradayTimeHtml = [] # list of html code for short term option ssToShow = None intradayTimeHtml.append('<option value="longTerm">longTerm</option>') for ss in ssList: if showPeriod != 'longTerm': # target seleted date's scoreStructure if ss.date == seletedDateTimeStr[:10].replace("/", " "): ssToShow = ss if not ss.date == 'model': # generate option list for short term tempDateTime = datetime(int(ss.date[6:10]), int(ss.date[3:5]), int(ss.date[:2]), hour=int(ss.time[:2]), minute=int(ss.time[3:5])) intradayTime.append(tempDateTime) intradayTimeHtml.append( '<option value="%(val)s">%(text)s</option>' % { 'val': tempDateTime.strftime('%d/%m/%Y - %Hh%M'), 'text': tempDateTime.strftime('%d/%m/%Y - %Hh%M') }) if showPeriod == 'longTerm': ssToShow = ssList[0] # for showing finance score in long term page if not isinstance(df, str): import matplotlib.pyplot as plt, mpld3 # 2D plotting library # plotIndicator(df, 'RS') # rs = mpld3.fig_to_html(plt.gcf()) # plt.close() plotIndicator(df, 'Bollinger', startShowPoint=startShowPoint, endShowPoint=endShowPoint, title=showPeriod) bollinger = mpld3.fig_to_html(plt.gcf()) plt.close() plotIndicator(df, 'MA', startShowPoint=startShowPoint, endShowPoint=endShowPoint, title=showPeriod) ma = mpld3.fig_to_html(plt.gcf()) plt.close() plotIndicator(df, 'MACD', startShowPoint=startShowPoint, endShowPoint=endShowPoint, title=showPeriod) macd = mpld3.fig_to_html(plt.gcf()) plt.close() plotIndicator(df, 'RSI', startShowPoint=startShowPoint, endShowPoint=endShowPoint, title=showPeriod) rsi = mpld3.fig_to_html(plt.gcf()) plt.close() plotIndicator(df, 'Stochastic', startShowPoint=startShowPoint, endShowPoint=endShowPoint, title=showPeriod) stoschastic = mpld3.fig_to_html(plt.gcf()) plt.close() fig = [bollinger, ma, macd, rsi, stoschastic] if showPeriod == 'longTerm': # long term use a different template return render_template( 'stockLongTerm.html', name=name, fig=fig, shortTermDateTimeOption=intradayTimeHtml, financeScore=ssToShow.finance['Score'].as_matrix()) else: return render_template( 'stock.html', name=name, fig=fig, score=ssToShow.graphic['Score'].as_matrix(), raison=ssToShow.graphic['Reason'].as_matrix(), shortTermDateTimeOption=intradayTimeHtml, seletedDateTimeStr=seletedDateTimeStr, criterionScore=ssToShow.criterion['Result'].as_matrix(), finalScore=ssToShow.finalScore) elif df == "Intraday history no more available.</br>": return render_template( 'stock.html', name=name, fig=[df, df, df, df, df], score=ssToShow.graphic['Score'].as_matrix(), raison=ssToShow.graphic['Reason'].as_matrix(), shortTermDateTimeOption=intradayTimeHtml, seletedDateTimeStr=seletedDateTimeStr, criterionScore=ssToShow.criterion['Result'].as_matrix(), finalScore=ssToShow.finalScore) else: return render_template('readError.html', name=name)
def service_type_plot(self, df, urls_map=None, interactive=True, asl=False): fig, ax = plt.subplots(nrows=1, ncols=1) years = list(df['Financial Year'].unique()) service_types = list(df['Service type'].unique()) width = 0.25 bars_list = [] # Draw the bar graphs for i, year in enumerate(years): group_df = df[df['Financial Year'] == year] group = group_df['Sum of ASL'] if asl else group_df['Sum of Total'] pos = [ service_types.index(x) for x in group_df['Service type'].values ] bar_lefts = self._get_lefts(i, len(years), width, pos) bars = ax.bar(bar_lefts, group, color=_set_periods_colors(year), width=width, linewidth=4, edgecolor=_set_periods_colors(year), zorder=2) bars_list.append({'bars': bars, 'values': group}) # Set chart properties and formatting fig.set_size_inches(12, 6) ax.yaxis.set_major_formatter(FuncFormatter(self.format_amount)) ax.tick_params(axis='y', which='major', labelsize=14, labelcolor='#2F2F31', length=0) if interactive: ax.tick_params(axis='x', which='major', labelsize=14, length=0) xlabels = [x.title() for x in service_types] ax.set_xticks(range(len(xlabels))) ax.set_xticklabels(xlabels) else: ax.tick_params(axis='x', which='major', labelsize=9.5, length=0) xlabels = [x.replace(' ', '\n') for x in service_types] ax.set_xticklabels([], position=(0, -0.04), clip_on=True) ax.spines['top'].set_visible(False) ax.spines['right'].set_visible(False) ax.spines['left'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.yaxis.grid(color='lightgray', linewidth=2) yaxis_label = 'ASL' if asl else 'Dollars' ax.set_ylabel(yaxis_label, fontsize=14) # Draw the legend handles = [] for i, year in enumerate(years): patch = mpatches.Patch(color=_set_periods_colors(year), label=year, linewidth=4) handles.append(patch) if interactive: ax.legend(handles=handles, loc='best') else: ax.legend(handles=handles, frameon=False, loc='center right', bbox_to_anchor=(1.15, 0.5)) # Data table df2 = pd.DataFrame([], columns=service_types) def get_value(df, x): try: if asl: value = df.loc[x]['Sum of ASL'] else: value = df.loc[x]['Sum of Total'] return value except KeyError: return 0 for i, year in enumerate(years, 1): year_df = df[df['Financial Year'] == year] year_df.set_index('Service type', inplace=True) df2.loc[year] = [get_value(year_df, x) for x in service_types] df2['Total Cost'] = [df2.loc[year].sum() for year in df2.index.values] if asl: for year in years: df2.loc[year] = df2.loc[year].apply('{:.2f}'.format) else: for year in years: df2.loc[year] = df2.loc[year].apply('{:.2f}'.format) if interactive: # Create tooltips for bars for bars_group in bars_list: for i, bar in enumerate(bars_group['bars'].get_children()): value = list(bars_group['values'])[i] if asl: formatted_value = '{:.2f} ASL'.format(value) else: formatted_value = '${:,.0f}'.format(value) label = "<div style='background: white; padding: 2px; border: solid 1px black;'>%s</div>" % formatted_value tooltip = mpld3.plugins.LineHTMLTooltip(bar, label=label, hoffset=15, voffset=-5) mpld3.plugins.connect(fig, tooltip) # Create links in x-axis labels mpld3.plugins.connect(fig, TickLabelLink(urls_map)) # Format the y-axis values mpld3.plugins.connect(fig, YTickFormat('dollar thousands')) # Create the agency counts table html = mpld3.fig_to_html(fig) table_json = df2.to_dict('split') return html, table_json else: data_table = ax.table(cellText=df2.as_matrix(), colLabels=xlabels, rowLabels=years, loc='bottom') data_table.auto_set_font_size(False) data_table.set_fontsize(9.5) # Adjust cell heights data_table.scale(1, 2) cells = data_table.get_celld() for x, y in cells: cell = cells[(x, y)] if x == 0: cell.set_height(0.2) cell.set_linewidth(0.5) cell.set_linestyle('dashed') fig.tight_layout() return fig
fig_amps_errs = _gen_amps_errs_plot(amps_orig, singles_or, amps_extr, singles_det, amps_errs_bins, amps_errs_range) fig_times_errs = _gen_times_errs_plot(pos_orig, singles_or, pos_extr, singles_det, times_errs_bins, times_errs_range) md = markdown(OUT_TEMPLATE) html = Environment(loader=BaseLoader()).from_string(md).render( method=metrics_all['method'], total=len(amps_orig), extr_all=len(amps_extr), extr_all_perc=len(amps_extr) / len(amps_orig) * 100, extr_fpos=len(false_pos), extr_fpos_perc=len(false_pos) / len(amps_extr) * 100, extr_ok=len(singles_or), extr_ok_perc=len(singles_or) / len(amps_extr) * 100, extr_ovlpd=len(mult_or), extr_ovlpd_perc=len(mult_or) / len(amps_extr) * 100, hist_plot=mpld3.fig_to_html(fig_hist), amp_errs_plot=mpld3.fig_to_html(fig_amps_errs), times_errs_plot=mpld3.fig_to_html(fig_times_errs)) fig_hist.show() fig_amps_errs.show() fig_times_errs.show() plt.show() serve(html)
def states_problem_min_banks_prob_not_changed(bailout_cost, deadweight_cost, discount_rate, nr_of_periods, opt_pi_bank): # State's problem: min if Bank's probabilitie is not changed # Solve the equation from (20) on: v_state_opt_min = [0] * nr_of_periods pi_state_tresh_min = [0] * nr_of_periods opt_pi_bank_min = opt_pi_bank # n=0, pi=0 does not change f_state_0 = lambda x: math.pow( -deadweight_cost + bailout_cost + discount_rate * deadweight_cost * (1 - x) / (1 - discount_rate * x), 2) pi_state_tresh_min[0] = optimize.root(f_state_0, 0.5, method='lm').x v_state_opt_min[0] = deadweight_cost * (1 - opt_pi_bank_min[0]) / ( 1 - discount_rate * opt_pi_bank_min[0]) # previous periods, n > 0: f_state = lambda x,y: math.pow(- deadweight_cost + bailout_cost + discount_rate * (bailout_cost + discount_rate * y) * \ (1 - x) / (1 - discount_rate * x),2) n_end = 0 for i in range(1, nr_of_periods): f_state_opt = lambda x: f_state(x, v_state_opt_min[i - 1]) pi_state_tresh_min[i] = optimize.root(f_state_opt, 0.5, method='lm').x if min(deadweight_cost, bailout_cost + discount_rate * v_state_opt_min[i - 1]) == deadweight_cost: n_end = nr_of_periods - i + 1 v_state_opt_min[i] = min(deadweight_cost, bailout_cost + discount_rate * v_state_opt_min[i-1]) *\ (1 - opt_pi_bank_min[i]) / (1 - discount_rate * opt_pi_bank_min[i]) nr_per = [0] * nr_of_periods for i in range(0, nr_of_periods): nr_per[i] = i # Create plots and pdf file. Save pdf file into graphics folder fig6, ax = pyplot.subplots() ax.plot(nr_per, flipud(opt_pi_bank_min), label='Bank', color='red', linestyle=':') ax.plot(nr_per, flipud(pi_state_tresh_min), label='State', color='blue', linestyle='--') ax.set_xlabel('Stage of the Game') ax.set_ylabel('Probability') ax.set_title('Optimal Probabilities') ax.legend(loc='lower left', frameon=True, fontsize='medium', title='', fancybox=True) html_text_fig6 = mpld3.fig_to_html(fig6) pyplot.savefig( 'tbtf/modelfinitebounded/graphics/FB_Optimal_Probabilities_Banks_Prob_not_changed.pdf', format='pdf') pyplot.close(fig6) fig7, bx = pyplot.subplots() bx.plot(nr_per, flipud(v_state_opt_min), label='Value', color='red') bx.set_xlabel('Stage of the Game') bx.set_ylabel('Value') bx.set_title('State value if it choses whether to save the bank') bx.legend(loc='lower left', frameon=True, fontsize='medium', title='', fancybox=True) html_text_fig7 = mpld3.fig_to_html(fig7) pyplot.savefig( 'tbtf/modelfinitebounded/graphics/FB_State_Value_if_choses_whether_to_save_the_Bank.pdf', format='pdf') pyplot.close(fig7) return html_text_fig6, html_text_fig7
def generateReport(self, user, org, today, lds_df, maps_df, top_5_maps_date, analysis_types_df, analysis_df, dsets_df, tables_sizes, top_5_dsets_date, top_5_dsets_size, sync, private, link, public, geo, none_tbls, points, lines, polys, fig_analysis, fig_lds): ''' Method to generate a HTML report. ''' self.logger.info('Generating HTML template...') template = """ <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <meta http-equiv="X-UA-Compatible" content="ie=edge"> <title>CARTO Database Metrics Report Template</title> <link rel="stylesheet" href="https://libs.cartocdn.com/airship-style/v1.0.3/airship.css"> <script src="https://libs.cartocdn.com/airship-components/v1.0.3/airship.js"></script> <style> .as-sidebar{ width: 33.33%; } .as-box{ border-bottom: 1px solid #F5F5F5; } </style> </head> <body class="as-app-body as-app"> <header class="as-toolbar"> <div class="as-toolbar__item as-title"> CARTO Metrics Report </div> <div class="as-toolbar__item as-display--block as-p--12 as-subheader as-bg--complementary"> {{ user }} from {{org}} at {{today}} </div> </header> <div class="as-content"> <aside class="as-sidebar as-sidebar--left"> <div class="as-container"> <h1 class="as-box as-title as-font--medium"> Maps and Analysis </h1> <div class="as-box"> <h2 class="as-title"> Maps </h2> <p class="as-body as-font--medium">Number of maps: {{total_maps}}</p> <div class="as-box" id="maps-table"> <h3 class="as-subheader">Top 5 Maps by Date</h3> {{top_5_maps_date.to_html()}} </div> </div> <div class="as-box"> <h2 class="as-title"> Builder Cached Analysis </h2> <ul class="as-list"> <li class="as-list__item">Number of cached analyses: {{total_analysis}}</li> <li class="as-list__item">Cached Analyses Size: {{total_size_analysis}} MB</li> </ul> <div class="as-box" id="analysis-table"> {{analysis_types_df.to_html()}} </div> <div class="as-box" id="analysis-fig"> {{html_fig_analysis}} </div> </div> </div> </aside> <main class="as-main"> <h1 class="as-box as-title as-font--medium"> Storage Quota & LDS </h1> <div class="as-box"> <h2 class="as-title"> Storage Quota </h2> <ul class="as-list"> <li class="as-list__item as-font--medium">Account Storage: {{real_storage}} MB</li> <li class="as-list__item as-color--support-01">Used Quota: {{used_storage}} MB, {{pc_used}} %</li> <li class="as-list__item as-color--complementary">Quota Left: {{left_storage}} MB, {{pc_left}} %</li> </ul> </div> <div class="as-box"> <h2 class="as-title"> Location Data Services </h2> <div class="as-box" id="lds-table"> {{lds.to_html()}} </div> <div class="as-box" id="lds-fig"> {{html_fig_lds}} </div> </div> </main> <aside class="as-sidebar as-sidebar--right"> <div class="as-container"> <div class="as-box as-title as-font--medium"> Datasets </div> <div class="as-box"> <h2 class="as-title"> Datasets Summary </h2> <ul class="as-list"> <li class="as-list__item as-font--medium">Number of tables: {{total_dsets}}</li> <li class="as-list__item">Sync tables: {{sync}}</li> <li class="as-list__item">Tables Size: {{total_size_tbls}} MB</li> </ul> </div> <div class="as-box"> <h2 class="as-title"> Privacy </h2> <ul class="as-list"> <li class="as-list__item as-color--support-01">🔒 Private: {{private}} tables</li> <li class="as-list__item as-color--support-02">🔗 Shared with link: {{link}} tables</li> <li class="as-list__item as-color--support-03">🔓 Public: {{public}} tables</li> </ul> </div> <div class="as-box"> <h2 class="as-title"> Geometry </h2> <p class="as-body"> Number of geocoded tables: {{geo}} </p> <ul class="as-list"> <li class="as-list__item">📌 Points: {{points}} tables</li> <li class="as-list__item">〰️ Lines: {{lines}} tables</span></li> <li class="as-list__item">⬛ Polygons: {{polys}} tables</li> </ul> <p class="as-body"> Number of non-geocoded tables: {{none_tbls}} </p> </div> <div class="as-box" id="tables-size"> <h3 class="as-subheader">Top 5 Datasets by Size</h3> {{top_5_dsets_size.to_html()}} </div> <div class="as-box" id="tables-date"> <h3 class="as-subheader">Top 5 Datasets by Date</h3> {{top_5_dsets_date.to_html()}} </div> </div> </aside> </div> <script> // add airship class to tables const tableElements = document.querySelectorAll('table'); tableElements.forEach(element => element.classList.add("as-table")); </script> </body> </html> """ rtemplate = Environment(loader=BaseLoader()).from_string(template) self.logger.info('Rendering HTML report...') report = rtemplate.render({ # user and date info 'user': user, 'org': org, 'today': today, # lds and storage info 'lds': lds_df, 'real_storage': lds_df.iloc[3]['Monthly Quota'], 'used_storage': lds_df.iloc[3]['Used'], 'pc_used': lds_df.iloc[3]['% Used'], 'left_storage': lds_df.iloc[3]['Left'], 'pc_left': round(lds_df.iloc[3]['% Left'], 2), # maps info 'total_maps': len(maps_df), 'total_analysis': len(analysis_df), 'total_size_analysis': analysis_df['size'].sum(), 'analysis_types_df': analysis_types_df, 'top_5_maps_date': top_5_maps_date, # datasets info 'sync': sync, 'total_dsets': len(dsets_df), 'total_size_tbls': tables_sizes['size'].sum(), 'top_5_dsets_size': top_5_dsets_size[['size']], 'top_5_dsets_date': top_5_dsets_date[['created']], # privacy info 'private': private, 'link': link, 'public': public, # geometry info 'geo': geo, 'points': points, 'lines': lines, 'polys': polys, 'none_tbls': none_tbls, # figures 'html_fig_analysis': fig_to_html(fig_analysis), 'html_fig_lds': fig_to_html(fig_lds) }) return report
def render(self, idf, filename='output.html'): progress_inst = helpers.Progress(idf.opt) self.progress = progress_inst.progress if idf.opt['outputFilename']: filename = idf.opt['outputFilename'] if idf.opt['outputAs'] == 'html': # write matplotlib/d3 plots to html file import matplotlib import matplotlib.pyplot as plt, mpld3 import matplotlib.axes from mpld3 import plugins from jinja2 import Environment, FileSystemLoader elif idf.opt['outputAs'] in ['pdf', 'interactive', 'tikz']: # show plots in separate matplotlib windows import matplotlib if idf.opt['outputAs'] == 'pdf': from matplotlib.backends.backend_pdf import PdfPages pp = PdfPages(filename) import matplotlib.pyplot as plt import matplotlib.axes else: print("No proper output method given. Not plotting.") return font_size = 10 if idf.opt['outputAs'] in ['pdf', 'tikz']: if idf.opt['plotPerJoint']: font_size = 30 else: font_size = 12 matplotlib.rcParams.update({'font.size': font_size}) matplotlib.rcParams.update({'axes.labelsize': font_size - 5}) matplotlib.rcParams.update({'axes.linewidth': font_size / 15.}) matplotlib.rcParams.update({'axes.titlesize': font_size - 2}) matplotlib.rcParams.update({'legend.fontsize': font_size - 2}) matplotlib.rcParams.update({'xtick.labelsize': font_size - 5}) matplotlib.rcParams.update({'ytick.labelsize': font_size - 5}) matplotlib.rcParams.update({'lines.linewidth': font_size / 15.}) matplotlib.rcParams.update({'patch.linewidth': font_size / 15.}) matplotlib.rcParams.update({'grid.linewidth': font_size / 20.}) # skip some samples so graphs don't get too large/detailed TODO: change skip so that some # maximum number of points is plotted (determined by screen etc.) skip = 5 #create figures and plots figures = list() for ds in self.progress(range(len(self.datasets))): group = self.datasets[ds] fig, axes = plt.subplots(len(group['dataset']), sharex=True, sharey=True) # scale unified scaling figures to same ranges and add some margin if group['unified_scaling']: ymin = 0 ymax = 0 for i in range(len(group['dataset'])): ymin = np.min( (np.min(group['dataset'][i]['data']), ymin)) * 1.05 ymax = np.max( (np.max(group['dataset'][i]['data']), ymax)) * 1.05 #plot each group of data for d_i in range(len(group['dataset'])): d = group['dataset'][d_i] if not issubclass(type(axes), matplotlib.axes.SubplotBase): ax = axes[d_i] else: ax = axes axes = [axes] if idf.opt['outputAs'] != 'tikz': ax.set_title(d['title']) if group['unified_scaling']: ax.set_ylim([ymin, ymax]) for data_i in range(0, len(d['data'])): if len(d['data'][data_i].shape) > 1: #data matrices for i in range(0, d['data'][data_i].shape[1]): l = group['labels'][i] if data_i == 0 else '' if i < 6 and 'contains_base' in group and group[ 'contains_base']: ls = 'dashed' else: ls = '-' dashes = () # type: Tuple if idf.opt['plotErrors']: if idf.opt['plotPrioriTorques']: n = 3 else: n = 2 if i == n: ls = 'dashed' dashes = (3, 0.5) ax.plot(d['time'][::skip], d['data'][data_i][::skip, i], label=l, color=colors[i], alpha=1 - (data_i / 2.0), linestyle=ls, dashes=dashes) else: #data vector ax.plot(d['time'][::skip], d['data'][data_i][::skip], label=group['labels'][d_i], color=colors[0], alpha=1 - (data_i / 2.0)) ax.grid(which='both', linestyle="dotted", alpha=0.8) if 'y_label' in group: ax.set_ylabel(group['y_label']) if idf.opt['outputAs'] != 'tikz': ax.set_xlabel("Time (s)") plt.setp([a.get_xticklabels() for a in axes[:-1]], visible=False) #plt.setp([a.get_yticklabels() for a in axes], fontsize=8) if idf.opt['plotLegend']: handles, labels = ax.get_legend_handles_labels() if idf.opt['outputAs'] == 'html': #TODO: show legend properly (see mpld3 bug #274) #leg = fig.legend(handles, labels, loc='upper right', fancybox=True, fontsize=10, title='') leg = axes[0].legend(handles, labels, loc='upper right', fancybox=True, fontsize=10, title='', prop={'size': 8}) else: leg = plt.figlegend(handles, labels, loc='upper right', fancybox=True, fontsize=font_size, title='', prop={'size': font_size - 3}) leg.draggable() fig.subplots_adjust(hspace=2) fig.set_tight_layout(True) if idf.opt['outputAs'] == 'html': plugins.clear(fig) plugins.connect(fig, plugins.Reset(), plugins.BoxZoom(), plugins.Zoom(enabled=False), plugins.MousePosition(fontsize=14, fmt=".5g")) figures.append(mpld3.fig_to_html(fig)) elif idf.opt['outputAs'] == 'interactive': plt.show(block=False) elif idf.opt['outputAs'] == 'pdf': pp.savefig(plt.gcf()) elif idf.opt['outputAs'] == 'tikz': from matplotlib2tikz import save as tikz_save tikz_save('{}_{}_{}.tex'.format( filename, group['dataset'][0]['title'].replace('_', '-'), ds // idf.model.num_dofs), figureheight='\\figureheight', figurewidth='\\figurewidth', show_info=False) if idf.opt['outputAs'] == 'html': path = os.path.dirname(os.path.abspath(__file__)) template_environment = Environment( autoescape=False, loader=FileSystemLoader(os.path.join(path, '../output')), trim_blocks=False) context = {'figures': figures, 'text': self.text} outfile = os.path.join(path, '..', 'output', filename) import codecs with codecs.open(outfile, 'w', 'utf-8') as f: html = template_environment.get_template( "templates/index.html").render(context) f.write(html) print("Saved output at file://{}".format(outfile)) elif idf.opt['outputAs'] == 'interactive': #keep non-blocking plot windows open plt.show() elif idf.opt['outputAs'] == 'pdf': pp.close()
df['x'] = np.random.randn(N) df['y'] = np.random.randn(N) labels = [] for i in range(N): label = df.ix[[i], :].T label.columns = ['point {0}'.format(i)] # .to_html() is unicode; so make leading 'u' go away with str() labels.append(str(label.to_html())) points = ax.scatter(df.x, df.y, c=np.random.random(size=N), s=1000 * np.random.random(size=N), alpha=.6) ax.set_xlabel('x') ax.set_ylabel('y') ax.set_title('ScatterPlot', size=20) tooltip = plugins.PointHTMLTooltip(points, labels, voffset=10, hoffset=10, css=css) plugins.connect(fig, tooltip) mpld3.show() fig = plt.figure(1, figsize=(9, 6)) print(mpld3.fig_to_html(fig))
def graphic(request, funcion, iteraciones, lower_bound, upper_bound): import matplotlib.pyplot as plt, mpld3 import matplotlib.figure as fg import matplotlib import numpy as np import mpld3 from mpld3 import plugins, utils from matplotlib.patches import Polygon from pprint import pprint fig, ax = plt.subplots(figsize=(11,6.5)) # pprint(vars(fig)) # print ('#########################################3') x = np.linspace(-10, 10, 1000) #fig.subplots_adjust(right=2,top=1.1) #fig.adjustable='box' #fig.figsize=(5,2) # print(type(fig)) # fig.fg.Figure() # Ver atributos de un objeto # pprint(vars(fig)) # ax.legend_ = 'Raffo' # fig.figurePatch.set_width(3) # fig.figurePatch.set_height(3) # fig._animated=True # print(fig._animated) #paso de la funcion a graficar y='x**3 #iteraciones n=0 #limite inferior a=-10.0 #limite superior b=10.0 #fig.Figure(figsize=1000) """rect=[1,1,1,1] fig.add_axes(rect) fig.add_axes(rect, frameon=False, facecolor='g') fig.add_axes(rect, polar=True) fig.add_axes(rect, projection='polar') fig.add_axes(ax)""" # Propiedades de la linea que es definida por la funcion ax.plot(x,y, lw=5, alpha=0.7) # Add grid to figure ax.grid(True, alpha=0.3) #ax.set_ylim(-1.2, 1.0) #ax.text(5, -1.1, "Here are some curves", size=18) # Dibujar area bajo la curva ix = np.linspace(a, b) iy = ix verts = [(a, 0)] + list(zip(x, y)) + [(b, 0)] poly = Polygon(verts, facecolor='0.9', edgecolor='0.5') ax.add_patch(poly) # For transform it to HTML g = mpld3.fig_to_html(fig) return HttpResponse(g)
def draw(self, category, num_top_words_to_annotate=4, words_to_annotate=[], scores=None, transform=percentile_alphabetical): '''Outdated. MPLD3 drawing. Parameters ---------- category num_top_words_to_annotate words_to_annotate scores transform Returns ------- pd.DataFrame, html of fgure ''' try: import matplotlib.pyplot as plt except: raise Exception( "matplotlib and mpld3 need to be installed to use this function." ) try: from mpld3 import plugins, fig_to_html except: raise Exception("mpld3 need to be installed to use this function.") all_categories, other_categories = self._get_category_names(category) df = self._term_rank_score_and_frequency_df(all_categories, category, other_categories, scores) if self.x_coords is None: df['x'], df['y'] = self._get_coordinates_from_transform_and_jitter_frequencies \ (category, df, other_categories, transform) df_to_annotate = df[ (df['not category score rank'] <= num_top_words_to_annotate) | (df['category score rank'] <= num_top_words_to_annotate) | df['term'].isin(words_to_annotate)] words = list(df['term']) font = { 'family': 'sans-serif', 'color': 'black', 'weight': 'normal', 'size': 'large' } fig, ax = plt.subplots() plt.figure(figsize=(10, 10)) plt.gcf().subplots_adjust(bottom=0.2) plt.gcf().subplots_adjust(right=0.2) points = ax.scatter(self.x_coords, self.y_coords, c=-df['color_scores'], cmap='seismic', s=10, edgecolors='none', alpha=0.9) tooltip = plugins.PointHTMLTooltip( points, ['<span id=a>%s</span>' % w for w in words], css='#a {background-color: white;}') plugins.connect(fig, tooltip) ax.set_ylim([-.2, 1.2]) ax.set_xlim([-.2, 1.2]) ax.xaxis.set_ticks([0., 0.5, 1.]) ax.yaxis.set_ticks([0., 0.5, 1.]) ax.set_ylabel(category.title() + ' Frequency Percentile', fontdict=font, labelpad=20) ax.set_xlabel('Not ' + category.title() + ' Frequency Percentile', fontdict=font, labelpad=20) for i, row in df_to_annotate.iterrows(): # alignment_criteria = row['category score rank'] < row['not category score rank'] alignment_criteria = i % 2 == 0 horizontalalignment = 'right' if alignment_criteria else 'left' verticalalignment = 'bottom' if alignment_criteria else 'top' term = row['term'] ax.annotate( term, (self.x_coords[i], y_data[i]), size=15, horizontalalignment=horizontalalignment, verticalalignment=verticalalignment, ) # texts.append( # ax.text(row['dem freq scaled'], row['rep freq scaled'], row['word']) # ) # adjust_text(texts, arrowprops=dict(arrowstyle="->", color='r', lw=0.5)) plt.show() return df, fig_to_html(fig)
if first_only[i] and fi != 0: x[i] = [] y[i] = [] if labels: lab = labels[fi*len(fields):(fi+1)*len(fields)] else: lab = fields[:] if args.multi: col = colors[:] else: col = colors[fi*len(fields):] fig = plotit(x, y, lab, colors=col) for i in range(0, len(x)): x[i] = [] y[i] = [] if args.output is None: pylab.show() pylab.draw() input('press enter to exit....') else: fname, fext = os.path.splitext(args.output) if fext == '.html': import mpld3 html = mpld3.fig_to_html(fig) f_out = open(args.output, 'w') f_out.write(html) f_out.close() else: pylab.legend(loc=2,prop={'size':8}) pylab.savefig(args.output, bbox_inches='tight', dpi=200)
def joint_problem(r_max, r_min, bailout_cost, deadweight_cost, discount_rate, nr_of_periods): # Joint problem: after each stage Bank promises pi <= pi_state, but recalculates it's value opt_pi_bank_joint = [0] * nr_of_periods opt_pi_state_joint = [0] * nr_of_periods v_bank_joint = [0] * nr_of_periods v_state_joint = [0] * nr_of_periods # n=0 f_opt_bank_0 = lambda x: -x * (r_min + (r_max - r_min) * (1 - x)) / (1 - discount_rate * x) f_state_0 = lambda x: math.pow( -deadweight_cost + bailout_cost + discount_rate * deadweight_cost * (1 - x) / (1 - discount_rate * x), 2) opt_pi_bank_joint[0] = optimize.fmin( f_opt_bank_0, 0.5) # optimization using: Simplex method: the Nelder-Mead opt_pi_state_joint[0] = optimize.root(f_state_0, 0.5, method='lm').x # Bank "promises" the threshold pi in order to be saved at period n=1 even it it's optimal pi is lower: if opt_pi_bank_joint[0] < opt_pi_state_joint[0]: opt_pi_bank_joint[0] = opt_pi_state_joint[0] v_bank_joint[0] = -f_opt_bank_0(opt_pi_bank_joint[0]) v_state_joint[0] = deadweight_cost * (1 - opt_pi_bank_joint[0]) / ( 1 - discount_rate * opt_pi_bank_joint[0]) # Previous periods: f_bank = lambda x, y: -((x * (r_min + (r_max - r_min) * (1 - x)) + (1 - x) * (bailout_cost + discount_rate * y)) / (1 - discount_rate * x)) f_state = lambda x,y: math.pow(- deadweight_cost + bailout_cost + discount_rate * (bailout_cost + discount_rate * y) * \ (1 - x) / (1 - discount_rate * x), 2) # Options = optimset('TolFun', 1e-15): for i in range(1, nr_of_periods): f_opt_bank = lambda x: f_bank(x, v_bank_joint[i - 1]) f_state_opt = lambda x: f_state(x, v_state_joint[i - 1]) opt_pi_bank_joint[i] = optimize.fmin(f_opt_bank, 0.7) opt_pi_state_joint[i] = optimize.root(f_state_opt, 0.5, method='lm').x # BANKS's PROBABILITES CHANGED IF THEY ALE LOWER THAN PI_STATE AND THEN THEY ARE TAKEN FOR V's: if opt_pi_bank_joint[i] < opt_pi_state_joint[i]: opt_pi_bank_joint[i] = opt_pi_state_joint[i] v_bank_joint[i] = -f_opt_bank(opt_pi_bank_joint[i]) v_state_joint[i] = (bailout_cost + discount_rate * v_state_joint[i-1]) * (1 - opt_pi_bank_joint[i]) /\ (1 - discount_rate * opt_pi_bank_joint[i]) nr_per = [0] * nr_of_periods for i in range(0, nr_of_periods): nr_per[i] = i # Create plots and pdf file. Save pdf file into graphics folder fig8, ax = pyplot.subplots() ax.plot(nr_per, flipud(opt_pi_bank_joint), label='Bank', color='red', linestyle=':') ax.plot(nr_per, flipud(opt_pi_state_joint), label='State', color='blue', linestyle='--') ax.set_xlabel('Stage of the Game') ax.set_ylabel('Probability') ax.set_title('Optimal probabilities in joint game') ax.legend(loc='lower left', frameon=True, fontsize='medium', title='', fancybox=True) html_text_fig8 = mpld3.fig_to_html(fig8) pyplot.savefig( 'tbtf/modelfinitebounded/graphics/FB_Optimal_Probabilities_in_Joint_Game.pdf', format='pdf') pyplot.close(fig8) fig9, bx = pyplot.subplots() bx.plot(nr_per, flipud(v_state_joint), color='red') bx.set_title('State value in the joint game') bx.legend(loc='lower left', frameon=True, fontsize='medium', title='', fancybox=True) html_text_fig9 = mpld3.fig_to_html(fig9) pyplot.savefig( 'tbtf/modelfinitebounded/graphics/FB_State_Value_in_the_Joint_Game.pdf', format='pdf') pyplot.close(fig9) return html_text_fig8, html_text_fig9
def service_profile_plot(self, service_name, df1, df2, deidentified=False, browser='edge', asl=False, selected_agency_name=''): # Initialize list that should contain the subplots subplots = [] #--------------------------------------------------- # Initialize the figure and axes for the scatterplot #--------------------------------------------------- fig = plt.figure(figsize=(7, 5)) gs = gridspec.GridSpec(2, 1, height_ratios=[6, 1.5]) unit_type = df1.columns[1] ax1 = fig.add_subplot(gs[0, 0]) profiles = df1[df1['Type'] == 'WofG Agencies'] dot_size = 100 if browser == 'edge': dot_size = 30 scatter1 = ax1.scatter(profiles[unit_type], profiles['Unit Rates'], c=colors[0], s=dot_size, zorder=2) selected_orgs = df1[df1['Type'] == selected_agency_name] scatter2 = None if len(selected_orgs): scatter2 = ax1.scatter(selected_orgs[unit_type], selected_orgs['Unit Rates'], c="#ec4a41", s=dot_size, zorder=2) ax1.set_ylabel('Unit Rates', fontsize=12) ax1.set_xlabel(unit_type, fontsize=12) # Grid and labels formatting ax1.yaxis.grid(color='lightgray', linewidth=2, zorder=1) ax1.xaxis.grid(color='lightgray', linewidth=2, zorder=1) ax1.set_title(service_name, position=(0.5, 1.12), fontsize=18) ax1.text(0.5, 1.1, '(Unit Type = %s)' % unit_type, transform=ax1.transAxes, ha='center', va='center', fontsize=14) for axis in ['top', 'bottom', 'left', 'right']: ax1.spines[axis].set_linewidth(3) # Draw the tooltip for each point def format_label(agency, unit_type, x, y): style = 'style="background: white; border: 1px solid black; padding: 5px;"' if agency: label = '<div {}><strong>{}</strong><br>'.format(style, agency) else: label = '<div {}>'.format(style) label += '{}: {:,.0f}<br>Unit Rate: {:,.2f}</div>'.format( unit_type, x, y) return label for sdf, points in [(profiles, scatter1), (selected_orgs, scatter2)]: if points: labels = zip(sdf['Agency name'], sdf[unit_type], sdf['Unit Rates']) labels = [ format_label(agency, unit_type, x, y) for agency, x, y in labels ] tooltip = mpld3.plugins.PointHTMLTooltip(points, labels=labels, hoffset=15, voffset=-5) mpld3.plugins.connect(fig, tooltip) # Draw and format the legend ax2 = fig.add_subplot(gs[1, 0]) handles = [] for label, color in [('WofG Agencies', colors[0]), (selected_agency_name, '#ec4a41')]: circle = mlines.Line2D(range(1), range(1), marker='o', color='white', markerfacecolor=color, markeredgecolor=color, markersize=9, label=label) handles.append(circle) legend = ax2.legend(handles=handles, ncol=2, loc='lower center') frame = legend.get_frame() frame.set_facecolor('white') frame.set_linewidth(2) frame.set_edgecolor('black') mpld3.plugins.connect(fig, HideSuplotAxes(2)) html = mpld3.fig_to_html(fig) # We can eventually remove the code above # but for now, we'll just stop providing it to the template. # This is deprecated by a template-driven JS charting library. # subplots.append(html) #--------------------------------------------------------- # Initialize the figure and axes for the stacked bar graph #--------------------------------------------------------- fig = plt.figure(figsize=(7, 5)) gs = gridspec.GridSpec(2, 1, height_ratios=[6, 1.5]) ax1 = fig.add_subplot(gs[0, 0]) # Create a color mapping in tuples cost_types = list(df2['Cost Type'].dropna().values) cost_types.sort() cost_type_colors = zip(cost_types, colors[0:len(df2)]) colors_dict = dict(cost_type_colors) df2['Order'] = df2['Cost Type'].dropna().apply( lambda x: cost_types.index(x)) df2['Color'] = df2['Cost Type'].dropna().apply( lambda x: colors_dict[x]) df2 = df2.dropna(subset=['Cost Type']).sort_values('Order', ascending=False) def create_stacked_bar(pos, values, colors, cost_types): width = 0.5 lastx = 0 bars_list = [] for x, color, cost_type in list(zip(values, colors, cost_types)): bar = ax1.bar(pos, x, width, bottom=lastx, color=color) lastx += x bars_list.append({'bar': bar, 'value': x, 'name': cost_type}) return bars_list bar_groups = { 1: { 'name': service_name }, 2: { 'name': 'WofG Agencies - %s' % service_name } } df2.sort_values('Cost Type', inplace=True) for bg in bar_groups: bars = create_stacked_bar(bg, df2[bar_groups[bg]['name']], df2['Color'], df2['Cost Type']) #if interactive: for bar in bars: style = 'style="background: white; border: 1px solid black; padding: 2px;"' label = '<div {}><strong>{}</strong><br>Percentage: {:,.2f}%</div>' label = label.format(style, bar['name'], bar['value']) tooltip = mpld3.plugins.LineHTMLTooltip( bar['bar'].get_children()[0], label=label, hoffset=15, voffset=-5) mpld3.plugins.connect(fig, tooltip) ax1.set_title('Compare Your Cost Categories', position=(0.5, 1.05), fontsize=18) percentage_by = 'ASL' if asl else 'Dollars' ax1.set_ylabel('Percentage - {}'.format(percentage_by), fontsize=12) def draw_subplot2_legend(ax): # Draw the legend handles = [] for cost_type, color in colors_dict.items(): if cost_type != 'Unknown': patch = mpatches.Patch(color=color, label=cost_type) handles.append(patch) legend = ax.legend(handles=handles, loc='lower center', ncol=3) frame = legend.get_frame() frame.set_linewidth(2) frame.set_facecolor('#f0f3ee') frame.set_edgecolor('#dbe0d5') return legend ax1.xaxis.set_label_coords(0.5, -0.1) ax1.yaxis.set_label_coords(-0.1, 0.5) ax1.set_xlim(0, 3) ax1.set_xticks([1, 2]) ax1.set_xticklabels( [service_name, 'WofG Agencies - %s' % service_name]) ax2 = fig.add_subplot(gs[1, 0]) draw_subplot2_legend(ax2) mpld3.plugins.connect(fig, HideSuplotAxes(2)) html = mpld3.fig_to_html(fig) subplots.append(html) return { 'subplots': subplots, 'data': { 'profiles': profiles.to_dict(), 'agency': selected_orgs.to_dict() } }
def service_classification_plot(self, agency_count_df, df, urls_map=None, interactive=True, asl=False): self.interactive = interactive fig, ax = plt.subplots(nrows=1, ncols=1) years = list(df['Financial Year'].unique()) service_classes = list(df['Service classification'].unique()) width = 0.25 bars_list = [] # Draw the bar graphs for i, year in enumerate(years): group_df = df[df['Financial Year'] == year] group = group_df['Sum of ASL'] if asl else group_df['Sum of Total'] pos = [ service_classes.index(x) for x in group_df['Service classification'].values ] bar_lefts = self._get_lefts(i, len(years), width, pos) bars = ax.bar(bar_lefts, group, color=_set_periods_colors(year), width=width, linewidth=4, edgecolor=_set_periods_colors(year), zorder=2) bars_list.append({'values': group, 'bars': bars}) # Set chart properties and formatting fig.set_size_inches(12, 6) ax.yaxis.set_major_formatter(FuncFormatter(self.format_amount)) ax.tick_params(axis='y', which='major', labelsize=14, labelcolor='#2F2F31', length=0) ax.tick_params(axis='x', which='major', labelsize=14, labelcolor='#2F2F31', length=0) xlabels = df['Service classification'].unique() ax.set_xticks([p for p in range(len(xlabels))]) if interactive: labels = ax.set_xticklabels(xlabels) else: rotation = 0 halign = 'center' # Adjust alignment and rotation if there are more than 4 labels if len(xlabels) > 4: rotation = 45 halign = 'right' labels = ax.set_xticklabels(xlabels, fontweight='semibold', rotation=rotation, position=(0, -0.04)) for label in labels: label.set_horizontalalignment(halign) ax.spines['top'].set_visible(False) ax.spines['right'].set_visible(False) ax.spines['left'].set_visible(False) ax.spines['bottom'].set_visible(False) ax.yaxis.grid(color='lightgray', linewidth=2) yaxis_label = 'ASL' if asl else 'Dollars' ax.set_ylabel(yaxis_label, fontsize=14) # Draw the legend handles = [] for i, year in enumerate(years): patch = mpatches.Patch(color=_set_periods_colors(year), label=year, linewidth=4) handles.append(patch) if interactive: ax.legend(handles=handles, frameon=False, loc='best') else: ax.legend(handles=handles, frameon=False, loc='center right', bbox_to_anchor=(1.15, 0.5)) # Prepare the agency counts table agency_count_df.fillna(0, inplace=True) # Data table df1 = pd.DataFrame([], columns=service_classes) def get_value(df, x): try: if asl: value = df.loc[x]['Sum of ASL'] else: value = df.loc[x]['Sum of Total'] return value except KeyError: return 0 for i, year in enumerate(years, 1): year_df = df[df['Financial Year'] == year] year_df.set_index('Service classification', inplace=True) df1.loc[year] = [get_value(year_df, x) for x in service_classes] if asl: for year in years: df1.loc[year] = df1.loc[year].apply('{:.2f}'.format) else: for year in years: df1.loc[year] = df1.loc[year].apply('{:.2f}'.format) if interactive: # Create tooltips for bars for bars_group in bars_list: for i, bar in enumerate(bars_group['bars'].get_children()): value = list(bars_group['values'])[i] if asl: formatted_value = '{:.2f} ASL'.format(value) else: formatted_value = '${:,.0f}'.format(value) label = "<div style='background: white; padding: 2px; border: solid 1px black;'>%s</div>" % formatted_value tooltip = mpld3.plugins.LineHTMLTooltip(bar, label=label, hoffset=15, voffset=-5) mpld3.plugins.connect(fig, tooltip) # Create links in x-axis labels mpld3.plugins.connect(fig, TickLabelLink(urls_map)) # Format the y-axis values mpld3.plugins.connect(fig, YTickFormat('dollar thousands')) # Create the agency counts table html = mpld3.fig_to_html(fig) agency_count_table_json = agency_count_df.to_dict('split') table_json = df1.to_dict('split') return html, agency_count_table_json, table_json else: ax.table(cellText=agency_count_df.as_matrix(), rowLabels=agency_count_df.index, colLabels=agency_count_df.columns, bbox=[0, 1.1, 0.5, 0.7], loc='top') fig.tight_layout() return fig
def urenderGraph(dataSet): """ This function renders a graph for the use in the specialized word graphs. This portion of the code was not completed at the time of submission, and so this function is currently not being used. """ tdata=dataSet[0] sdata=dataSet[1] tsize=len(tdata) fig=plt.figure(1) fig.set_size_inches(11,(tsize*2.25)) #fig.set_size_inches(18.5, 10.5, forward=True) counter=1 for word, num in tdata: for tword, value in sdata.items(): tempwords=[] tempcounts=[] tempucounts=[] if(word==tword): for sword, counts in value: tempwords.append(sword) tempcounts.append(counts[0]) tempucounts.append(counts[1]) ax=plt.subplot(tsize,1,counter, autoscale_on=True) ind = np.arange(len(tempcounts)) # the x locations for the groups width = 0.35 # the width of the bars rects1 = ax.bar(ind, tempcounts, width, color='r') rects2 = ax.bar(ind+.35, tempucounts, width, color='b') ax.set_ylabel("Occurances") ax.set_title(word) ax.set_xticks(ind + width / 2) ax.set_xticklabels(tempwords) uautolabel(rects1,ax) uautolabel(rects2,ax) counter+=1 # data = dataSet[0] # title = dataSet[1] # ylabel = dataSet[2] # xlabels = dataSet[3] # data2 = dataSet[4] #bool1 = dataSet[5] # ind = np.arange(len(data)) # the x locations for the groups # width = 0.35 # the width of the bars #fig, ax = plt.subplots() #print 'Before figure' #chart = plt.figure(1) #print 'After first figure' # add some text for labels, title and axes ticks # ax.set_ylabel(ylabel) # ax.set_title(title) # ax.set_xticks(ind + width / 2) # ax.set_xticklabels(xlabels) #fig_to_html attempt #current error: 'Figure' object has no attribute 'fig_to_html' #needed to download jinja2 for mpld3 to work fig.tight_layout() graphOutput = plt.figure() #initialize variable as current graph to be later passed on to HTML code graphHTML = fig_to_html(fig) #convert current graph to HTML code #print (graphHTML) #if(bool1==1): #plt.show() plt.close(graphOutput) #close the current graph mpld3.display(fig) return graphHTML
def states_problem_change_banks_pi(bailout_cost, deadweight_cost, discount_rate, nr_of_periods, opt_pi_bank, v_state_opt): # State's problem: Change Bank's pi if it's less then State's pi # solve the equation from (20) on: v_state_opt_switch = [0] * nr_of_periods pi_state_tresh_switch = [0] * nr_of_periods opt_pi_bank_switch = [0] * nr_of_periods # n=0 f_state_0 = lambda x: math.pow( -deadweight_cost + bailout_cost + discount_rate * deadweight_cost * (1 - x) / (1 - discount_rate * x), 2) pi_state_tresh_switch[0] = optimize.fsolve(f_state_0, 0.5) # Bank's "promises" the threshold pi in order to be saved at period n=1 even # if it's optimal pi is lower: if opt_pi_bank[0] < pi_state_tresh_switch[0]: opt_pi_bank_switch[0] = pi_state_tresh_switch[0] else: opt_pi_bank_switch[0] = opt_pi_bank[0] v_state_opt_switch[0] = deadweight_cost * (1 - opt_pi_bank_switch[0]) / ( 1 - discount_rate * opt_pi_bank_switch[0]) # previous periods f_state = lambda x,y: math.pow(- deadweight_cost + bailout_cost + discount_rate * (bailout_cost + discount_rate * y) * \ (1 - x) / (1 - discount_rate * x),2) # solve for all the previous periods: for i in range(1, nr_of_periods): f_state_opt = lambda x: f_state(x, v_state_opt_switch[i - 1]) pi_state_tresh_switch[i] = optimize.fsolve(f_state_opt, 0.5) # BANK's PROBABILITIES CHANGED IF THEY ALE LOWER THAN PI_STATE AND THEN THEY ARE TAKEN FOR V's: if opt_pi_bank[i] < pi_state_tresh_switch[i]: opt_pi_bank_switch[i] = pi_state_tresh_switch[i] else: opt_pi_bank_switch[i] = opt_pi_bank[i] v_state_opt_switch[i] = (bailout_cost + discount_rate * v_state_opt_switch[i-1]) * (1 - opt_pi_bank_switch[i])\ / (1 - discount_rate * opt_pi_bank_switch[i]) nr_per = [0] * nr_of_periods for i in range(0, nr_of_periods): nr_per[i] = i # Create plots and pdf file. Save pdf file into graphics folder fig4, ax = pyplot.subplots() ax.plot(nr_per, flipud(opt_pi_bank), label='Bank', color='red') ax.plot(nr_per, flipud(pi_state_tresh_switch), label='State', color='blue', linestyle=':') ax.plot(nr_per, flipud(opt_pi_bank_switch), label='Bank Switched', color='green', linestyle='--') ax.set_xlabel('Stage of the Game') ax.set_ylabel('Probability') ax.set_title('Optimal Probabilities') ax.legend(loc='lower left', frameon=True, fontsize='medium', title='', fancybox=True) html_text_fig4 = mpld3.fig_to_html(fig4) pyplot.savefig( 'tbtf/modelfinitebounded/graphics/FB_Optimal_Probabilities_Change_Banks_PI.pdf', format='pdf') pyplot.close(fig4) fig5, bx = pyplot.subplots() bx.plot(nr_per, flipud(v_state_opt_switch), label='New value (Bank switches)', color='red', linestyle=':') bx.plot(nr_per, flipud(v_state_opt), label='Old value', color='blue', linestyle='--') bx.set_title('State value if Bank switches to state pi') bx.legend(loc='lower left', frameon=True, fontsize='medium', title='', fancybox=True) html_text_fig5 = mpld3.fig_to_html(fig5) pyplot.savefig( 'tbtf/modelfinitebounded/graphics/FB_State_Value_if_Bank_switches_to_State_PI.pdf', format='pdf') pyplot.close(fig5) return html_text_fig4, html_text_fig5
def generate_plot(tran, ambig, min_read, max_read, master_filepath_dict, lite, offset_dict, ribocoverage, organism, normalize, short_code, background_col, hili_start, hili_stop, comp_uag_col, comp_uga_col, comp_uaa_col, trips_annotation_location, title_size, subheading_size, axis_label_size, marker_size, cds_marker_size, cds_marker_colour, legend_size, transcriptome): labels = [] start_visible = [] line_collections = [] all_stops = ["TAG", "TAA", "TGA"] returnstr = "Position," y_max = 50 if normalize == True: y_max = 0 connection = sqlite3.connect( '/home/DATA/www/tripsviz/tripsviz/trips.sqlite') connection.text_factory = str cursor = connection.cursor() cursor.execute( "SELECT owner FROM organisms WHERE organism_name = '{}' and transcriptome_list = '{}';" .format(organism, transcriptome)) owner = (cursor.fetchone())[0] if owner == 1: transhelve = sqlite3.connect("{0}{1}/{1}.v2.sqlite".format( trips_annotation_location, organism)) else: transhelve = sqlite3.connect( "{0}transcriptomes/{1}/{2}/{3}/{2}_{3}.v2.sqlite".format( trips_uploads_location, owner, organism, transcriptome)) cursor = transhelve.cursor() cursor.execute( "SELECT * from transcripts WHERE transcript = '{}'".format(tran)) result = cursor.fetchone() traninfo = { "transcript": result[0], "gene": result[1], "length": result[2], "cds_start": result[3], "cds_stop": result[4], "seq": result[5], "strand": result[6], "stop_list": result[7].split(","), "start_list": result[8].split(","), "exon_junctions": result[9].split(","), "tran_type": result[10], "principal": result[11] } traninfo["stop_list"] = [int(x) for x in traninfo["stop_list"]] traninfo["start_list"] = [int(x) for x in traninfo["start_list"]] if str(traninfo["exon_junctions"][0]) != "": traninfo["exon_junctions"] = [ int(x) for x in traninfo["exon_junctions"] ] else: traninfo["exon_junctions"] = [] transhelve.close() gene = traninfo["gene"] tranlen = traninfo["length"] cds_start = traninfo["cds_start"] cds_stop = traninfo["cds_stop"] strand = traninfo["strand"] if cds_start == 'NULL' or cds_start == None: cds_start = 0 if cds_stop == 'NULL' or cds_stop == None: cds_stop = 0 all_starts = traninfo["start_list"] all_stops = {"TAG": [], "TAA": [], "TGA": []} seq = traninfo["seq"].upper() for i in range(0, len(seq)): if seq[i:i + 3] in all_stops: all_stops[seq[i:i + 3]].append(i + 1) start_stop_dict = { 1: { "starts": [0], "stops": { "TGA": [0], "TAG": [0], "TAA": [0] } }, 2: { "starts": [0], "stops": { "TGA": [0], "TAG": [0], "TAA": [0] } }, 3: { "starts": [0], "stops": { "TGA": [0], "TAG": [0], "TAA": [0] } } } for start in all_starts: rem = ((start - 1) % 3) + 1 start_stop_dict[rem]["starts"].append(start - 1) for stop in all_stops: for stop_pos in all_stops[stop]: rem = ((stop_pos - 1) % 3) + 1 start_stop_dict[rem]["stops"][stop].append(stop_pos - 1) fig = plt.figure(figsize=(23, 12)) ax_main = plt.subplot2grid((30, 1), (0, 0), rowspan=22) if normalize != True: label = 'Read count' else: label = 'Normalized read count' ax_main.set_ylabel(label, fontsize=axis_label_size, labelpad=30) label = 'Position (nucleotides)' ax_main.set_xlabel(label, fontsize=axis_label_size, labelpad=10) #if normalize is true work out the factors for each colour if normalize == True: all_mapped_reads = [] for color in master_filepath_dict: all_mapped_reads.append( master_filepath_dict[color]["mapped_reads"]) min_reads = float(min(all_mapped_reads)) for color in master_filepath_dict: factor = min_reads / float( master_filepath_dict[color]["mapped_reads"]) master_filepath_dict[color]["factor"] = factor # So items can be plotted alphabetically unsorted_list = [] for color in master_filepath_dict: input_list = [ color, master_filepath_dict[color]["file_names"], master_filepath_dict[color]["file_descs"], master_filepath_dict[color]["file_ids"], master_filepath_dict[color]["filepaths"], master_filepath_dict[color]["file_type"], master_filepath_dict[color]["minread"], master_filepath_dict[color]["maxread"] ] if "factor" in master_filepath_dict[color]: input_list.append(master_filepath_dict[color]["factor"]) unsorted_list.append(input_list) sorted_list = sorted(unsorted_list, key=lambda x: x[1][0]) returndict = {} for item in sorted_list: # needed to make get_reads accept file_paths file_paths = {"riboseq": {}} for i in range(0, len(item[3])): file_paths["riboseq"][item[3][i]] = item[4][i] file_names = item[1][0] file_descs = item[2] if item[5] == "riboseq": filename_reads, seqvar_dict = get_reads(ambig, item[6], item[7], tran, file_paths, tranlen, ribocoverage, organism, False, False, "fiveprime", "riboseq", 1) else: filename_reads, seqvar_dict = get_reads(ambig, item[6], item[7], tran, file_paths, tranlen, True, organism, False, False, "fiveprime", "riboseq", 1) if normalize == False: try: max_val = max(filename_reads.values()) * 1.1 if max_val > y_max: y_max = max_val except Exception as e: print "Error", e pass labels.append(file_names) start_visible.append(True) plot_filename = ax_main.plot(filename_reads.keys(), filename_reads.values(), alpha=1, label=labels, zorder=1, color=item[0], linewidth=3) line_collections.append(plot_filename) returndict[file_names] = {} for pos in filename_reads: returndict[file_names][pos] = filename_reads[pos] else: normalized_reads = {} for pos in filename_reads: normalized_reads[pos] = filename_reads[pos] * item[8] try: max_val = max(normalized_reads.values()) * 1.1 if max_val > y_max: y_max = max_val except Exception as e: print "Error", e pass labels.append(file_names) start_visible.append(True) plot_filename = ax_main.plot(normalized_reads.keys(), normalized_reads.values(), alpha=1, label=labels, zorder=1, color=item[0], linewidth=3) line_collections.append(plot_filename) returndict[file_names] = {} for pos in filename_reads: returndict[file_names][pos] = normalized_reads[pos] for plot_filename in returndict: returnstr += "{},".format(plot_filename) returnstr += "\n" for i in range(0, tranlen): returnstr += "{},".format(i) for plot_filename in returndict: returnstr += "{},".format(returndict[plot_filename][i]) returnstr += "\n" ax_main.set_ylim(0, y_max) # draw cds start plt.plot((cds_start, cds_start), (0, y_max), cds_marker_colour, linestyle=':', linewidth=cds_marker_size) # draw cds end plt.plot((cds_stop, cds_stop), (0, y_max), cds_marker_colour, linestyle=':', linewidth=cds_marker_size) ax_f1 = plt.subplot2grid((30, 1), (27, 0), rowspan=1, sharex=ax_main) ax_f1.set_axis_bgcolor('lightgray') ax_f2 = plt.subplot2grid((30, 1), (28, 0), rowspan=1, sharex=ax_main) ax_f2.set_axis_bgcolor('lightgray') ax_f6 = plt.subplot2grid((30, 1), (29, 0), rowspan=1, sharex=ax_main) ax_f6.set_axis_bgcolor('lightgray') ax_f6.set_xlabel('Transcript: {} Length: {} nt'.format(tran, tranlen), fontsize=subheading_size, labelpad=10) for axis, frame in ((ax_f1, 1), (ax_f2, 2), (ax_f6, 3)): color = color_dict['frames'][frame - 1] axis.set_xlim(0, tranlen) starts = [(item, 1) for item in start_stop_dict[frame]['starts']] axis.broken_barh(starts, (0.5, 1), color='white', zorder=5, linewidth=2) stops = [(item, 1) for item in start_stop_dict[frame]['stops']] uag_stops = [(item, 1) for item in start_stop_dict[frame]['stops']['TAG']] uaa_stops = [(item, 1) for item in start_stop_dict[frame]['stops']['TAA']] uga_stops = [(item, 1) for item in start_stop_dict[frame]['stops']['TGA']] axis.broken_barh(uag_stops, (0, 1), color=comp_uag_col, zorder=2, linewidth=2) axis.broken_barh(uaa_stops, (0, 1), color=comp_uaa_col, zorder=2, linewidth=2) axis.broken_barh(uga_stops, (0, 1), color=comp_uga_col, zorder=2, linewidth=2) axis.set_ylabel('{}'.format(frame), rotation='horizontal', labelpad=10, verticalalignment='center') axis.set_ylim(0, 1) axis.tick_params(top=False, left=False, right=False, bottom=False, labeltop=False, labelleft=False, labelright=False, labelbottom=False) ax_f6.axes.get_yaxis().set_ticks([]) ax_f2.axes.get_yaxis().set_ticks([]) ax_f1.axes.get_yaxis().set_ticks([]) title_str = '{} ({})'.format(gene, short_code) plt.title(title_str, fontsize=title_size, y=36) if not (hili_start == 0 and hili_stop == 0): hili_start = int(hili_start) hili_stop = int(hili_stop) hili = ax_main.fill_between([hili_start, hili_stop], [y_max, y_max], zorder=0, alpha=0.75, color="#fffbaf") labels.append("Highligter") start_visible.append(True) line_collections.append(hili) leg_offset = (legend_size - 17) * 5 if leg_offset < 0: leg_offset = 0 leg_offset += 230 ilp = plugins.InteractiveLegendPlugin(line_collections, labels, alpha_unsel=0.05, xoffset=leg_offset, yoffset=20, start_visible=start_visible, fontsize=legend_size) plugins.connect(fig, ilp, plugins.TopToolbar(yoffset=100), plugins.DownloadProfile(returnstr=returnstr), plugins.DownloadPNG(returnstr=title_str)) ax_main.set_axis_bgcolor(background_col) # This changes the size of the tick markers, works on both firefox and chrome. ax_main.tick_params('both', labelsize=marker_size) ax_main.xaxis.set_major_locator(plt.MaxNLocator(3)) ax_main.yaxis.set_major_locator(plt.MaxNLocator(3)) ax_main.grid(color="white", linewidth=20, linestyle="solid") graph = "<div style='padding-left: 55px;padding-top: 22px;'> <a href='https://trips.ucc.ie/short/{0}' target='_blank' ><button class='button centerbutton' type='submit'><b>Direct link to this plot</b></button></a> </div>".format( short_code) graph += mpld3.fig_to_html(fig) return graph
def states_problem(bailout_cost, deadweight_cost, discount_rate, nr_of_periods, opt_pi_bank): # State's Problem # solve the equations from (20) on: v_state_opt = [0] * nr_of_periods pi_state_thresh = [0] * nr_of_periods x = math.pow(5, 2) # Period n=0 f_state_0 = lambda x: math.pow( -deadweight_cost + bailout_cost + discount_rate * deadweight_cost * (1 - x) / (1 - discount_rate * x), 2) pi_state_thresh[0] = optimize.fsolve(f_state_0, 0.5) v_state_opt[0] = deadweight_cost * (1 - opt_pi_bank[0]) / ( 1 - discount_rate * opt_pi_bank[0]) # previous periods: f_state = lambda x, y: math.pow( -deadweight_cost + bailout_cost + discount_rate * (bailout_cost + discount_rate * y) * (1 - x) / (1 - discount_rate * x), 2) # solve for the rest of the periods: for i in range(1, nr_of_periods): f_state_opt = lambda x: f_state(x, v_state_opt[i - 1]) pi_state_thresh[i] = optimize.fsolve(f_state_opt, 0.5) #BANK's PROBABILITIE'sS ARE TAKEN FOR v_state v_state_opt[i] = (bailout_cost + discount_rate * v_state_opt[i - 1]) * (1 - opt_pi_bank[i]) / \ (1 - discount_rate * opt_pi_bank[i]) nr_per = [0] * nr_of_periods for i in range(0, nr_of_periods): nr_per[i] = i # Create plots and pdf file. Save pdf file into graphics folder fig2, ax = pyplot.subplots() ax.plot(nr_per, flipud(opt_pi_bank), label='Bank', color='red', linestyle=':') ax.plot(nr_per, flipud(pi_state_thresh), label='State', color='blue', linestyle='--') ax.set_xlabel('Stage of the Game') ax.set_ylabel('Probability') ax.set_title('Optimal Probabilities') ax.legend(loc='upper left', frameon=0, fontsize='medium', title='', fancybox=True) html_text_fig2 = mpld3.fig_to_html(fig2) pyplot.savefig( 'tbtf/modelfinitebounded/graphics/FB_Optimal_Probabilities.pdf', format='pdf') pyplot.close(fig2) fig3, bx = pyplot.subplots() bx.plot(nr_per, flipud(v_state_opt), label='Bank', color='red') bx.set_title('State Value') bx.legend(loc='lower left', frameon=0, fontsize='medium', title='', fancybox=True) html_text_fig3 = mpld3.fig_to_html(fig3) pyplot.savefig('tbtf/modelfinitebounded/graphics/FB_State_Value.pdf', format='pdf') pyplot.close(fig3) return html_text_fig2, html_text_fig3, v_state_opt
def main(): import argparse import argcomplete basic_desc = "experimental tool for opening a serialized PlotCollection (pickle format)" lic = "(c) [email protected]" main_parser = argparse.ArgumentParser(description="%s %s" % (basic_desc, lic)) main_parser.add_argument("in_file", help="path to a serialized plot_collection") main_parser.add_argument("-t", "--title", help="custom title (default: file name)") main_parser.add_argument("--save_plot", help="path to save plot", default=None) main_parser.add_argument("--serialize_plot", help="path to re-serialize PlotCollection", default=None) main_parser.add_argument("--to_html", help="convert to html (requires mpld3 library)", action="store_true") main_parser.add_argument("--no_warnings", help="no warnings requiring user confirmation", action="store_true") argcomplete.autocomplete(main_parser) args = main_parser.parse_args() from evo.tools import log, plot, user log.configure_logging(verbose=True) if not args.title: title = os.path.basename(args.in_file) else: title = args.title if not args.no_warnings: logger.warning( "Please note that this tool is experimental and not guranteed to work.\n" "Only works if the same plot settings are used as for serialization.\n" "If not, try: evo_config show/set \n" + SEP) plot_collection = plot.PlotCollection(title, deserialize=args.in_file) logger.debug("deserialized PlotCollection: " + str(plot_collection)) plot_collection.show() if args.serialize_plot: logger.debug(SEP) plot_collection.serialize(args.serialize_plot, confirm_overwrite=not args.no_warnings) if args.save_plot: logger.debug(SEP) plot_collection.export(args.save_plot, confirm_overwrite=not args.no_warnings) if args.to_html: import mpld3 logger.debug(SEP + "\nhtml export\n") for name, fig in plot_collection.figures.items(): html = mpld3.fig_to_html(fig) out = name + ".html" with open(out, 'w') as f: logger.debug(out) f.write(html) if not args.no_warnings: logger.debug(SEP) if user.confirm("save changes & overwrite original file " + args.in_file + "? (y/n)"): plot_collection.serialize(args.in_file, confirm_overwrite=False)
def create_interactive_figure(): css = """ h5 { font-size: 1.5em; margin-top: 0.83em; margin-bottom: 0.83em; margin-left: 0.83em; margin-right: 0.83em; color: #0099ff; background-color: rgba(255,255,255,0.8); } h6 { font-size: 1.5em; margin-top: 0.83em; margin-bottom: 0.83em; margin-left: 0.83em; margin-right: 0.83em; color: #ff3300; background-color: rgba(255,255,255,0.8); } """ c5 = '#0099ff' c6 = '#ff3300' fig = plt.figure(figsize=(5, 7)) ax = fig.gca() try: # plot comparison if requested points_ref = ax.plot(comparison_T, comparison_z, marker='o', ms=5, label=comparison_label, c=c6) labels_ref = [] for i in range(comparison_z.size): label_ref = '<h6>Height: {:.1f} km<br>{}: {:.1f} {}</h6>'.format( comparison_z[i], xlabel, comparison_T[i], xunits) labels_ref.append(label_ref) tooltip_ref = mpld3.plugins.PointHTMLTooltip(points_ref[0], labels_ref, voffset=10, hoffset=10, css=css) comparison = True except ValueError: comparison = False pass points = ax.plot(T, z, marker='o', ms=5, label='your run', c=c5) plt.xlabel(f'{xlabel} [{xunits}]') plt.ylabel('Height [km]') plt.ylim(0, np.max(z)) leg = plt.legend() leg.get_frame().set_edgecolor('white') labels = [] for i in range(z.size): label = '<h5>Height: {:.1f} km<br>{}: {:.1f} {}</h5>'.format( z[i], xlabel, T[i], xunits) labels.append(label) tooltip_user = mpld3.plugins.PointHTMLTooltip(points[0], labels, voffset=10, hoffset=10, css=css) if comparison: mpld3.plugins.connect(fig, tooltip_user, tooltip_ref) else: mpld3.plugins.connect(fig, tooltip_user) return mpld3.fig_to_html(fig)
import os import matplotlib.pyplot as plt import mpld3 from util import update_html_string fig = plt.figure() plt.plot([1, 2, 3]) html_fig = mpld3.fig_to_html(fig) # look for a div with the following id html_target_id = os.path.basename(__file__) print(html_target_id) with open( r'C:\Users\Ben Smus\Learning_Programming\Web\bensmus.github.io\index.html' ) as f: html_existing = f.read() with open( r'C:\Users\Ben Smus\Learning_Programming\Web\bensmus.github.io\index.html', 'w') as f: html_new = update_html_string(html_existing, html_fig, html_target_id) f.write(html_new)
titleVar = 'NVIDIA Corporation' stk = "NVDA" else: print('Error! Error! Errrooorrrr!') labels = [] stock.to_csv('stock.csv') fig1 = plt.figure(1) plt.plot(stock["Adj Close"]) # Plot the adjusted closing price of stock plt.grid() fnt2 = plt.title("Last 1 year prices of " + titleVar) # Title for plot fnt2.set_size(18) plt.xlabel('Months') plt.ylabel('Stock price ' + titleVar) mpld3.fig_to_html(fig1) mpld3.save_html(fig1, "plot.html") fig2 = plt.figure(2) start = datetime.datetime.now().date() + datetime.timedelta(-31) stock_val = pd.read_csv('stock.csv') new_stock_val = stock_val[['Date', 'Close']] new_stock_val = stock_val[pd.to_datetime(stock_val['Date']) > pd.to_datetime( start)] ## Select values only upto previous month. This was hard :( new_stock_val.to_csv('stock2.csv') x = new_stock_val['Date'] y = new_stock_val['Close'] plt.grid() plt.plot_date(x, y, fmt="r-", marker='o', color='b') ## show blue dots fnt1 = plt.title("Last 1 month stock value of " + titleVar) fnt1.set_size(18)