def plot_similarity(self, result, parameter): source1 = column_source(result, "FDA") source2 = column_source(result, "PPI") source3 = column_source(result, "MACRO") source4 = column_source(result, "NP") source5 = column_source(result, "FDA PEP") source6 = column_source(result, "linear") source7 = column_source(result, "cyclic") hover = HoverTool(tooltips=[ ("sim", "$x"), ("CDF", "$y"), ]) p = figure( title="CDF of Tanimoto Similarity, based on: " + parameter[0], x_axis_label="Similarity", y_axis_label="Cumulative Distribution Function", x_range=(0, 1), y_range=(0, 1), tools=[hover], plot_width=1000, plot_height=800, ) p.add_tools(LassoSelectTool(), ZoomInTool(), ZoomOutTool(), SaveTool(), PanTool()) FDA_plot = p.line(x="x", y="y", source=source1, color="darkslateblue", line_width=3) PPI_plot = p.line(x="x", y="y", source=source2, color="yellowgreen", line_width=3) MACRO_plot = p.line(x="x", y="y", source=source3, color="lightsteelblue", line_width=3) NP_plot = p.line(x="x", y="y", source=source4, color="olive", line_width=3) PEP_FDA_plot = p.line(x="x", y="y", source=source5, color="darkslategray", line_width=3) LIN_plot = p.line(x="x", y="y", source=source6, color="teal", line_width=3) CYC_plot = p.line(x="x", y="y", source=source7, color="mediumvioletred", line_width=3) legend = Legend( items=[ ("FDA", [FDA_plot]), ("PPI", [PPI_plot]), ("MACRO", [MACRO_plot]), ("NP", [NP_plot]), ("PEP FDA", [PEP_FDA_plot]), ("LIN", [LIN_plot]), ("CYC", [CYC_plot]), ], location="center", orientation="vertical", click_policy="hide", ) p.add_layout(legend, place="right") p.xaxis.axis_label_text_font_size = "20pt" p.yaxis.axis_label_text_font_size = "20pt" p.xaxis.axis_label_text_color = "black" p.yaxis.axis_label_text_color = "black" p.xaxis.major_label_text_font_size = "18pt" p.yaxis.major_label_text_font_size = "18pt" p.title.text_font_size = "22pt" return p
'@y1')]) hover_pie = HoverTool(tooltips=[('Percentage', '@ratio')]) select_day = Select(options=[ 'Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday' ], value='Monday', title='Day of the Week') chosen_tools = [ hover, ResetTool(), BoxSelectTool(), SaveTool(), PanTool(), UndoTool(), RedoTool(), ZoomInTool(), ZoomOutTool() ] #data data = pd.read_csv(r'~/Desktop/yelp/yelp_business.csv', index_col='business_id') hour = pd.read_csv(r'~/Desktop/yelp/yelp_business_hours.csv', index_col='business_id') whole = pd.merge(data, hour, left_index=True, right_index=True)
def large_plot(n: int) -> Tuple[Model, Set[Model]]: from bokeh.models import ( BoxSelectTool, BoxZoomTool, Column, ColumnDataSource, DataRange1d, GlyphRenderer, Grid, Line, LinearAxis, PanTool, Plot, ResetTool, SaveTool, WheelZoomTool, ZoomInTool, ZoomOutTool, ) col = Column() objects: Set[Model] = {col} for i in range(n): source = ColumnDataSource(data=dict(x=[0, i + 1], y=[0, i + 1])) xdr = DataRange1d() ydr = DataRange1d() plot = Plot(x_range=xdr, y_range=ydr) xaxis = LinearAxis() plot.add_layout(xaxis, "below") yaxis = LinearAxis() plot.add_layout(yaxis, "left") xgrid = Grid(dimension=0) plot.add_layout(xgrid, "center") ygrid = Grid(dimension=1) plot.add_layout(ygrid, "center") tickers = [ xaxis.ticker, xaxis.formatter, yaxis.ticker, yaxis.formatter ] glyph = Line(x='x', y='y') renderer = GlyphRenderer(data_source=source, glyph=glyph) plot.renderers.append(renderer) pan = PanTool() zoom_in = ZoomInTool() zoom_out = ZoomOutTool() wheel_zoom = WheelZoomTool() box_zoom = BoxZoomTool() box_select = BoxSelectTool() save = SaveTool() reset = ResetTool() tools = [ pan, zoom_in, zoom_out, wheel_zoom, box_zoom, box_select, save, reset ] plot.add_tools(*tools) col.children.append(plot) objects |= set([ xdr, ydr, xaxis, xaxis.major_label_policy, yaxis, yaxis.major_label_policy, xgrid, ygrid, renderer, renderer.view, renderer.view.filter, glyph, source, source.selected, source.selection_policy, plot, plot.x_scale, plot.y_scale, plot.toolbar, plot.title, box_zoom.overlay, box_select.overlay, ] + tickers + tools) return col, objects
def generate_plot(self): """Iteratively reformats and plots self.data for each cell+model combo. TODO: Finish this doc """ plots = [] modelnames = self.data.index.levels[0].tolist() # Iterate over a list of tuples representing all unique pairs of models. for pair in list(itertools.combinations(modelnames,2)): tools = [ PanTool(), SaveTool(), WheelZoomTool(), ResetTool(), self.create_hover(), ] modelX = pair[0] modelY = pair[1] dataX = self.data.loc[modelX] dataY = self.data.loc[modelY] # Only necessary b/c bokeh's $index identifier for HoverTool() # is pulling an integer index despite data being indexed by cellid. # If cellid strings can be pulled from index instead, # this code will no longer be needed. cells = [] cellsX = list(set(dataX.index.values.tolist())) cellsY = list(set(dataY.index.values.tolist())) if self.fair: # cellsX and cellsY should be the same if fair was checked cells = cellsX if cells != cellsY: self.script = 'Problem with form_data_array:' self.div = 'Model x: ' + modelX + 'and Model y: ' + modelY\ + ' applied to different cells despite fair check.' return else: # If fair wasn't checked, use the longer list to avoid errors. if len(cellsX) >= len(cellsY): cells = cellsX else: cells = cellsY x_mean = np.mean(dataX[self.measure[0]]) x_median = np.median(dataX[self.measure[0]]) y_mean = np.mean(dataY[self.measure[0]]) y_median = np.median(dataY[self.measure[0]]) x_label = ( "{0}, mean: {1:5.4f}, median: {2:5.4f}" .format(modelX, x_mean, x_median) ) y_label = ( "{0}, mean: {1:5.4f}, median: {2:5.4f}" .format(modelY, y_mean, y_median) ) data = pd.DataFrame({ 'x_values':dataX[self.measure[0]], 'y_values':dataY[self.measure[0]], 'cellid':cells, }) dat_source = ColumnDataSource(data) p = figure( x_range=[0,1], y_range=[0,1], x_axis_label=x_label, y_axis_label=y_label, title=("{0}, prefix: {1}, suffix: {2}" .format(self.measure[0], self.pre, self.suf)), tools=tools, responsive=True, toolbar_location=TOOL_LOC, toolbar_sticky=TOOL_STICK, output_backend="svg" ) glyph = Circle( x='x_values', y='y_values', size=CIRCLE_SIZE, fill_color=CIRCLE_FILL, fill_alpha=CIRCLE_ALPHA, ) p.add_glyph(dat_source, glyph) p.line([0,1], [0,1], line_width=1, color='black') plots.append(p) # If more than one plot was made (i.e. 2 or more models were selected), # put them in a grid. #if len(plots) == 1: # singleplot = plots[0] # self.script,self.div = components(singleplot) # return #elif len(plots) > 1: grid = gridplot( plots, ncols=GRID_COLS, responsive=True, ) self.script,self.div = components(grid) if not plots: self.script, self.div = ( 'Error, no plots to display.', 'Make sure you selected two models.' )
def generate_plot(self): """TODO: write this doc.""" tools = [ PanTool(), SaveTool(), WheelZoomTool(), ResetTool(), ] x_values = [] y_values = [] std_errors = [] models = self.data.index.levels[0].tolist() for model in models: values = self.data[self.measure[0]].loc[model].values mean = np.mean(values) stderr = np.around(st.sem(values, nan_policy='omit'), 5) n_parms = self.data['n_parms'].loc[model].values[0] x_values.append(n_parms) y_values.append(mean) std_errors.append(stderr) newData = pd.DataFrame.from_dict({ 'stderr':std_errors, 'mean':y_values, 'n_parms':x_values, 'modelname':models, }) # Drop any models with NaN values, since that means they had no # performance data for one or more columns. newData.dropna(axis=0, how='any', inplace=True) if newData.size == 0: self.script,self.div = ( "Error, no plot to display.", "None of the models contained valid performance data." ) return dat_source = ColumnDataSource(newData) p = figure( tools=tools, x_axis_label=("N Parms, model prefix: {0}, " "suffix: {1}".format(self.pre, self.suf)), y_axis_label=("Mean {0}, +/- Standard Error" .format(self.measure[0])), title="Mean {0} per Model vs Complexity".format(self.measure[0]), output_backend="svg", sizing_mode='scale_width', ) circles = Circle( x='n_parms', y='mean', size=6, fill_color="navy", fill_alpha=0.7, ) circle_renderer = p.add_glyph(dat_source, circles) hover = self.create_hover() hover.renderers = [circle_renderer] p.add_tools(hover) #p.circle(x_values, y_values, size=6, color="navy", alpha=0.7) error_bars_x = [] error_bars_y = [] for i, std in enumerate(std_errors): error_bars_x.append([x_values[i], x_values[i]]) error_bars_y.append([y_values[i] - std, y_values[i] + std]) p.multi_line( error_bars_x, error_bars_y, color="firebrick", alpha=0.4, line_width=2, ) # workaround to prevent title and toolbar from overlapping grid = gridplot( [p], ncols=GRID_COLS, sizing_mode='scale_width' ) self.script, self.div = components(grid)
__author__ = "Anton Suchaneck" __email__ = "*****@*****.**" """ TODO: * check for NaN when sorting? * tick formatter in coffeescript with percent minauc: * minauc could be generally on x=pos+a*tot, y=pos+b*tot (?) -> prec would still be slope, only recall would be less visible * use ordered string values? """ heatmap_cmap = plt.cm.YlOrRd DEFAULT_MAX_PTS = 10000 DEFAULT_BOKEH_TOOLS = [BoxZoomTool(), PanTool(), ResetTool(), SaveTool()] def thin_out_idxs(x, max_len): """ :param x: sorted numpy array :param max_len: number of elements to sample :return: indices of selected elements Returns at most max_len indices 0...len(x)-1 such that the subsampled x are evenly spread """ if len(x) <= max_len: return np.arange(len(x)) val_min = x[0] val_max = x[-1]
def main(): DATASET = "_jobsv1_all" # 10k jobs, but also some low quality ones # OPT number of topics = ? #DATASET = "_jobsv1_goodq" # 5k jobs, selecting only higher quality ones # OPT number of topics = ? #DATASET = "_stackv1_graphicdesignqa_sub20k" # 20k subsets of q'n'a from graphic design # OPT number of topics = ? import numpy as np # < HAX numpy version # save np.load np_load_old = np.load # modify the default parameters of np.load np.load = lambda *a, **k: np_load_old(*a, allow_pickle=True, **k) # call load_data with allow_pickle implicitly set to true texts = np.load("data/texts" + DATASET + ".npz")['a'] data = np.load("data/documents" + DATASET + ".npz")['a'] titles = np.load("data/titles" + DATASET + ".npz")['a'] # restore np.load for future normal usage np.load = np_load_old # HAX numpy version /> plot_dir = "plots" + DATASET + "/" import os if not os.path.exists(plot_dir): os.makedirs(plot_dir) import pandas as pd from pprint import pprint import gensim import gensim.corpora as corpora from gensim.models import CoherenceModel import pyLDAvis import pyLDAvis.gensim # don't skip this import matplotlib.pyplot as plt import logging logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s', level=logging.ERROR) import warnings warnings.filterwarnings("ignore", category=DeprecationWarning) ### Settings: METAOPT_num_of_topics = True NAME_METAOPT_plot = plot_dir + "LDA_best_number_of_topics_" LOAD_lda_model = False LDA_tryMallet = False # doesn't have the same support as generic LDA tho - convert differently? LDA_number_of_topics = 13 # Wait for metaopt! CALC_coherence = True VIZ_hist = True VIZ_wordclouds = True VIZ_TSNE = True VIZ_html_interactive = True #SLOW and last NAME_hist = plot_dir + "hist_topics.png" NAME_tsne = plot_dir + "tsne.html" NAME_wordclouds = plot_dir + "wordclouds_" # +i+.png NAME_html_interactive = plot_dir + "LDA_Visualization.html" #"vis.html" DEBUG_print_docs = False DEBUG_print_topics = False SAVE_doc2topic = False # don't really need NAME_doc2topic = plot_dir + "doc2topic.csv" SAVE_topic2docs = True NAME_topic2docs = plot_dir + "topic2docs.csv" SAVE_topic2num = True NAME_topic2num = plot_dir + "topic2num.csv" # GENSIM analysis id2word = corpora.Dictionary(texts) corpus = [id2word.doc2bow(text) for text in texts] if DEBUG_print_docs: print("document in vector format:", corpus[:1]) print("readable form:", [[(id2word[id], freq) for id, freq in cp] for cp in corpus[:1]]) print() if METAOPT_num_of_topics: # Can take a long time to run. topics_start = 5 topics_end = 15 # non exclusive topics_step = 1 plot_name = NAME_METAOPT_plot + str(topics_start) + "TO" + str( topics_end) + "BY" + str(topics_step) + ".png" LDA_best_number_of_topics(id2word, corpus, texts, topics_start, topics_end, topics_step, mallet_lda=LDA_tryMallet, plot_name=plot_name) print("Analyze the results of the meta-optimalization ^^^") assert False # Build LDA model print("Building/Loading LDA model (takes time)") if LOAD_lda_model: lda_model = gensim.models.LdaModel.load('data/model_LDAEXAMPLE.lda') else: if LDA_tryMallet: # mallet LDA mallet_path = '../mallet-2.0.8/bin/mallet' # update this path lda_model = gensim.models.wrappers.LdaMallet( mallet_path, corpus=corpus, num_topics=LDA_number_of_topics, id2word=id2word) # convert lda_model = gensim.models.wrappers.ldamallet.malletmodel2ldamodel( lda_model) else: # normal LDA lda_model = gensim.models.ldamodel.LdaModel( corpus=corpus, id2word=id2word, num_topics=LDA_number_of_topics, random_state=100, update_every=1, chunksize=100, passes=10, alpha='auto', per_word_topics=True) lda_model.save('data/model_LDAEXAMPLE.lda') if DEBUG_print_topics: print("Topics:") pprint( lda_model.print_topics(num_topics=LDA_number_of_topics, num_words=5)) doc_lda = lda_model[corpus] # Evaluation - Perplexity, Coherence Score print('\nPerplexity: ', lda_model.log_perplexity( corpus)) # a measure of how good the model is. lower the better. if CALC_coherence: coherence_model_lda = CoherenceModel(model=lda_model, texts=texts, dictionary=id2word, coherence='c_v') coherence_lda = coherence_model_lda.get_coherence() print('\nCoherence Score: ', coherence_lda) ###################################################################################################### # Dominant topics per document if SAVE_doc2topic or SAVE_topic2docs or SAVE_topic2num or VIZ_hist: df_topic_sents_keywords, dominant_topics_as_arr = format_topics_sentences( ldamodel=lda_model, corpus=corpus, texts=data) df_dominant_topic = df_topic_sents_keywords.reset_index() df_dominant_topic.columns = [ 'Document_No', 'Dominant_Topic', 'Topic_Perc_Contrib', 'Keywords', 'Text' ] if SAVE_doc2topic: df_dominant_topic.to_csv(NAME_doc2topic, index=True) # Topic 2 representative documents if SAVE_topic2docs: sent_topics_sorteddf_mallet = pd.DataFrame() sent_topics_outdf_grpd = df_topic_sents_keywords.groupby( 'Dominant_Topic') for i, grp in sent_topics_outdf_grpd: sent_topics_sorteddf_mallet = pd.concat([ sent_topics_sorteddf_mallet, grp.sort_values(['Perc_Contribution'], ascending=[0]).head(1) ], axis=0) sent_topics_sorteddf_mallet.reset_index(drop=True, inplace=True) sent_topics_sorteddf_mallet.columns = [ 'Topic_Num', "Topic_Perc_Contrib", "Keywords", "Text" ] sent_topics_sorteddf_mallet.to_csv(NAME_topic2docs, index=True) # Topic 2 number of docs if SAVE_topic2num: topic_counts = df_topic_sents_keywords['Dominant_Topic'].value_counts() topic_contribution = round(topic_counts / topic_counts.sum(), 4) topic_num_keywords = df_topic_sents_keywords[[ 'Dominant_Topic', 'Topic_Keywords' ]] df_dominant_topics = pd.concat( [topic_num_keywords, topic_counts, topic_contribution], axis=1) df_dominant_topics.columns = [ 'Dominant_Topic', 'Topic_Keywords', 'Num_Documents', 'Perc_Documents' ] df_dominant_topics.to_csv(NAME_topic2num, index=True) # As a plot: if VIZ_hist: print("Saving histogram into >", NAME_hist) hist_tmp = {} for val in dominant_topics_as_arr: if val not in hist_tmp: hist_tmp[val] = 0 else: hist_tmp[val] += 1 print("My own hist:", hist_tmp) xs = list(range(LDA_number_of_topics)) ys = [0] * LDA_number_of_topics for topic_num, val in hist_tmp.items(): wp = lda_model.show_topic(topic_num) topic_keywords = ", ".join([word for word, prop in wp ]) # removed probabilities print("topic", topic_num, ":", val, "time(s) , keywords = ", topic_keywords) ys[topic_num] = val plt.bar(xs, ys) plt.xticks(np.arange(LDA_number_of_topics), np.arange(LDA_number_of_topics)) plt.savefig(NAME_hist) plt.close() import matplotlib.colors as mcolors colors_topics = [ color for name, color in mcolors.TABLEAU_COLORS.items() ] + [color for name, color in mcolors.XKCD_COLORS.items()] # Wordclouds of Top N words in each topic if VIZ_wordclouds: print("Saving wordclouds into >", NAME_wordclouds, "...") from matplotlib import pyplot as plt from wordcloud import WordCloud from nltk.corpus import stopwords stop_words = stopwords.words('english') stop_words.extend(['from', 'subject', 're', 'edu', 'use']) stoplist = set( ', . : / ( ) [ ] - _ ; * & ? ! – a b c d e t i p an us on 000 if it ll to as are then ' 'they our the you we s in if a m I x re to this at ref do and'. split()) stop_words.extend(stoplist) stoplist = set( 'experience job ensure able working join key apply strong recruitment work team successful ' 'paid contact email role skills company day good high time required want right success' 'ideal needs feel send yes no arisen arise title true'.split()) stop_words.extend(stoplist) stoplist = set( 'work experience role application process contract interested touch' .split()) stop_words.extend(stoplist) #topics = lda_model.show_topics(formatted=False) topics = lda_model.show_topics(num_topics=LDA_number_of_topics, formatted=False) for i_t, topic in enumerate(topics): topic_i = topic[0] topic_words = topic[1] print("topic", topic_i, "===", topic_words) fig = plt.figure() topic_words = dict(topic_words) cloud = WordCloud( stopwords=stop_words, background_color='white', width=2500, height=1800, max_words=10, colormap='tab10', color_func=lambda *args, **kwargs: colors_topics[topic_i], prefer_horizontal=1.0) cloud.generate_from_frequencies(topic_words, max_font_size=300) plt.gca().imshow(cloud) plt.gca().set_title('Topic ' + str(topic_i), fontdict=dict(size=16)) plt.axis('off') plt.margins(x=0, y=0) plt.tight_layout() plt.savefig(NAME_wordclouds + str(topic_i).zfill(2) + ".png") plt.close() # T-SNE if VIZ_TSNE: print("Saving TSNE visualization into >", NAME_tsne) from sklearn.manifold import TSNE from bokeh.plotting import figure, output_file, show, save, ColumnDataSource # Get topic weights doc_features = [] doc_titles = [] doc_dominanttopics = [] for i, row_list in enumerate(lda_model[corpus]): # What we have in the encoding: # row_list[0] = Document topics: [(0, 0.87507219282484316), (1, 0.12492780717515681)] # row_list[1] = Word topics: [(0, [0, 1]), (3, [0, 1]), (4, [0, 1]), (7, [0, 1])] # row_list[2] = Phi values: [(0, [(0, 0.9783234200583657), (1, 0.021676579941634355)]), (3, [(0, 0.93272653621872503), (1, 0.067273463781275009)]), (4, [(0, 0.98919912227661466), (1, 0.010800877723385368)]), (7, [(0, 0.97541896333079636), (1, 0.024581036669203641)])] # row_list[0] has the weights to topics # This means that one document was encoded into the LDA_number_of_topics topics we chose tmp = np.zeros(LDA_number_of_topics) max_w = -1 max_w_idx = -1 for j, w in row_list[0]: tmp[j] = w if max_w < w: max_w_idx = j max_w = w doc_features.append(tmp) doc_dominanttopics.append(max_w_idx) doc_titles.append(titles[i]) arr = pd.DataFrame(doc_features).fillna(0).values # tSNE Dimension Reduction tsne_model = TSNE(n_components=2, verbose=1, random_state=0, angle=.99, init='pca') tsne_lda = tsne_model.fit_transform(arr) TOOLTIPS = [ ("index", "$index"), ("(x,y)", "($x, $y)"), ("desc", "@desc"), ] mycolors = np.array(colors_topics) from bokeh.models import HoverTool, WheelZoomTool, PanTool, BoxZoomTool, ResetTool, SaveTool hover = HoverTool(tooltips=TOOLTIPS) tools = [ hover, WheelZoomTool(), PanTool(), BoxZoomTool(), ResetTool(), SaveTool() ] #plot = figure(title="t-SNE Clustering of {} LDA Topics".format(LDA_number_of_topics), # tooltips=TOOLTIPS, plot_width=900, plot_height=700) plot = figure(title="t-SNE Clustering of {} LDA Topics".format( LDA_number_of_topics), tools=tools, plot_width=900, plot_height=700) source = ColumnDataSource(data=dict( x=tsne_lda[:, 0], y=tsne_lda[:, 1], desc=doc_titles, color=mycolors[doc_dominanttopics], )) plot.scatter(x='x', y='y', source=source, color='color') output_file(NAME_tsne) save(plot) #show(plot) if VIZ_html_interactive: # Takes forever! print("creating visualization...") vis = pyLDAvis.gensim.prepare(lda_model, corpus, id2word) print("saving it...") pyLDAvis.save_html(vis, NAME_html_interactive) print("done")
def buildPlot(): #####################Setup # Grab graph colors, pop undesireable ones colors = SEABORN_PALETTES['bright'] #Grab and sort the FQs quals = fruit_df.reset_index() quals = quals['FruitQuality'].unique().tolist() for idx, i in enumerate(list(quals)): if type(i) == type(0.5): quals.pop(idx) unique_FQs = quals #a little math to get the epoch time to set the initial x range minDate = ts_to_epoch(fruit_df['Date'].min()) maxDate = ts_to_epoch(fruit_df['Date'].max()) ###########Create and format the plot plot = figure( x_axis_type="datetime", plot_width=600, plot_height=400, tools=[PanTool(), WheelZoomTool(), SaveTool(), BoxZoomTool()], x_range=DataRange1d( start=minDate, end=maxDate ), #sets the initial date range to the limits of the data y_range=DataRange1d(start=0, end=1), name='the_plot', toolbar_location='above') #some styling plot.title.text = "Historical Volatility" plot.xaxis.axis_label = "Trade Date" plot.yaxis.axis_label = "Vol" plot.background_fill_color = '#EAEBF0' plot.xgrid.grid_line_color = 'white' plot.ygrid.grid_line_color = 'white' plot.xaxis.axis_line_color = 'white' plot.xaxis.major_tick_line_color = 'white' plot.xaxis.minor_tick_line_color = 'white' plot.yaxis.axis_line_color = 'white' plot.yaxis.major_tick_line_color = 'white' plot.yaxis.minor_tick_line_color = 'white' plot.toolbar.logo = None #a list for all of the lines to reside in lines = [] legends = [] ##############Create the widgets #a console style window to show debug messages TODO: add on/off functionality debug = PreText(text="", width=1200, height=500) #echos the debug in a place more visiable for the user user_message = Paragraph(text='') #Asset_Class, Product, and From dropdown boxes. Sets dropdown's initial value. asCls = Select(title="Asset Class", options=ddOpts['Asset_Class'].unique().tolist()) asCls.value = asCls.options[0] prod = Select(title="Products", options=ddOpts[ddOpts['Asset_Class'] == asCls.value] ['Product'].unique().tolist()) prod.value = prod.options[0] whereFrom = Select(title="From", options=ddOpts[(ddOpts['Asset_Class'] == asCls.value) & (ddOpts['Product'] == prod.value)] ['From'].unique().tolist()) whereFrom.value = whereFrom.options[0] FQslider = Slider(title='Fruit Quality', start=min(unique_FQs), end=max(unique_FQs), step=1) #the amount of days back to look for the data days_back = TextInput(title='Days ago', value='365') days_back_buttons = RadioButtonGroup( labels=['10', '30', '90', '180', '365', '730'], active=4) #the date to linear fit to fixed_date_buttons = RadioButtonGroup( labels=['30', '60', '90', '120', '180', '365'], active=2) fixed_date = TextInput(title='Days to Exp', value='90') #the amount of days with which to calculate the rolling mean rolling_days_buttons = RadioButtonGroup(labels=['1', '2', '5', '10'], active=0) rolling_days = TextInput(title='Rolling Mean Days', value='1') #a dynamically resizing checkbox group that allows for the changing of the visablity of any line on the plot line_onOff = CheckboxGroup(width=400, name='line_onOff') #the associated colors to act as a legend for line_onOff legendDiv = Div(width=50) #button to add a line addLine = Button(label="Add Line") #an html rendered visualization of the data for each line descriptions = Div(text='', width=500) #resizes the plot rszButton = Button(label='resize') ##########Define functions associated with the widgets #concats any dubug call to the end of the current debug text, and changes the user message def updateDebug(inString): inString = str(inString) user_message.text = inString oldText = debug.text newText = ("*- " + str(datetime.now()) + " : " + inString) debug.text = oldText + '\n' + newText #changes the potential products and contract categories to match the user selected asset class def asClsChange(attrname, old, new): prod.options = ddOpts[ddOpts['Asset_Class'] == asCls.value]['Product'].unique().tolist() prod.value = prod.options[0] #changes the potential contract categories to match the user selected product def prodChange(attrname, old, new): whereFrom.options = ddOpts[(ddOpts['Asset_Class'] == asCls.value) & ( ddOpts['Product'] == prod.value)]['From'].unique().tolist() whereFrom.value = whereFrom.options[0] #links the days back button and text box def days_back_buttonChange(attrname, old, new): days_back.value = days_back_buttons.labels[days_back_buttons.active] #checks that the users input is an int def days_backChange(attrname, old, new): try: days_back.value = str(int(days_back.value)) except ValueError: days_back.value = '0' updateDebug('please type an integer') #links the fixed date button and text box def fixed_date_buttonChange(attrname, old, new): fixed_date.value = fixed_date_buttons.labels[fixed_date_buttons.active] #checks that the users input is an int def fixed_dateChange(attrname, old, new): try: fixed_date.value = str(int(fixed_date.value)) except ValueError: fixed_date.value = '0' updateDebug('please type an integer') #links the rolling days button and text box def rolling_days_buttonsChange(attrname, old, new): rolling_days.value = rolling_days_buttons.labels[ rolling_days_buttons.active] #checks that the users input is an int def rolling_daysChange(attrname, old, new): try: rolling_days.value = str(int(rolling_days.value)) except ValueError: rolling_days.value = '0' updateDebug('please type an integer') #fits the plot to the currently visiable lines def resize(): if len(line_onOff.active) == 0 or len(line_onOff.labels) == 0: plot.x_range.start = ts_to_epoch(fruit_df['Date'].min()) plot.x_range.end = ts_to_epoch(fruit_df['Date'].max()) plot.y_range.start = 0 plot.y_range.end = 100 else: xmin, xmax, ymin, ymax = calc_range(lines) plot.x_range.start = xmin plot.x_range.end = xmax plot.y_range.start = ymin plot.y_range.end = ymax #turn lines on or off def line_onOffChange(attrname, old, new): for i in range(len(line_onOff.labels)): if i in line_onOff.active: lines[i].glyph.visible = True else: lines[i].glyph.visible = False legendDiv.text = '<div>' for line in lines: legendDiv.text += '<br><div style="background-color: %s; float:up; padding: 4px 4px 4px 4px"></div><br>' % line.glyph.line_color legendDiv.text += '</div>' resize() #adds a line to the graph def grphUpdt(): #adds some debug messages, grabs the current time as to later show the total time taken to calculate updateDebug("Starting") updateDebug("total dataframe size: " + str(fruit_df.shape)) stTime = datetime.now() #the value to linear fit to fit_to = int(fixed_date.value) #instiantiate an empty dataframe that will eventually contain the graphs data graphData = pd.DataFrame({ 'Date': [], 'PriceVolatility': [], 'Days_to_Exp': [] }) #grab the appropriate subset of the whole dataframe based on the users input into the widgets updateDebug("querying the data..") try: workingDf = fruit_df.loc[asCls.value, prod.value, whereFrom.value] except KeyError: updateDebug( 'no data with that combination of Asset Class, Product, From') return try: workingDf = workingDf[[ 'Date', 'PriceVolatility', 'Days_to_Exp' ]][(workingDf['Date'] > (date.today() - timedelta(days=int(days_back.value))))] except KeyError: updateDebug( 'no data with that combination of Asset Class, Product, From, and days back' ) return updateDebug("done breaking down df") #a hook in the case that the users inputs resulted in an empty dataframe if (workingDf.empty): updateDebug( 'no data with that combination of Asset Class, Product, From, and days back' ) return #widdle down the database to only contain the user specified FQ try: graphData = workingDf.loc[int(FQslider.value)].copy() except KeyError: updateDebug('no data with that FQ') #another empty graph hook if (graphData.empty): updateDebug( 'no data with that combination of Asset Class, Product, Contract Category, FQ, and days back' ) return updateDebug('grabed correct FQs') #calculate linear fit on the current subset updateDebug('calculating linear fit...') graphData = mu.linearFit(fit_to=fit_to, group_on_column='Date', df=graphData, fit_column='Days_to_Exp', on_columns=['PriceVolatility']) updateDebug('finished with linear fit') # a few more debug messages updateDebug( "working df qry: Asset_Class = %s and Product = %s and From = %s and Date > %s " % (asCls.value, prod.value, whereFrom.value, str(date.today() - timedelta(days=int(days_back.value))))) updateDebug("graph data shape: " + str(workingDf.shape)) #makes sure graph data has at least 5 rows, so that rolling mean can be calculated if graphData.shape[0] > int(rolling_days.value): #make the graph legend, based on if there's a denominator specified or not this_legend = '%s - %s FQ: %s Days to Exp: %s From: %s Rolling Days: %s' % ( prod.value, whereFrom.value, int( FQslider.value), fixed_date.value, str(date.today() - timedelta(days=int(days_back.value))), rolling_days.value) #add a new line to the graph, and add the accosiated GlyphRenderer created by adding the line to the lines list. #Set the legend to the previously calculated legend, and set the color to the next color in the current theme (if there are more lines than colors, there will be multiple lines with the same color) #Calculates a 5 day rolling mean on the y values. Maybe add a slider/text box/other widget so the user can set the rolling mean themselves updateDebug('adding line to plot') lines.append( plot.line(graphData.index.values[int(rolling_days.value) - 1:], graphData['PriceVolatility'].rolling( window=int(rolling_days.value)).mean() [int(rolling_days.value) - 1:], line_width=3, color=colors[len(lines) % len(colors)])) legends.append(this_legend) updateDebug("updated graph") global descDf #either creates, or adds to, a dataframe containing statistics about the data. stats come from pandas DataFrame.describe. if descDf is None: graphData[this_legend] = graphData['PriceVolatility'] descDf = graphData[[ this_legend ]].rolling(window=int(rolling_days.value)).mean( )[int(rolling_days.value) - 1:].describe(percentiles=[]).transpose().copy() else: graphData[this_legend] = graphData['PriceVolatility'] descDf = pd.concat([ descDf, graphData[[ this_legend ]].rolling(window=int(rolling_days.value)).mean() [int(rolling_days.value) - 1:].describe(percentiles=[]).transpose().copy() ]) descDf = descDf.round(1) descriptions.text = descDf.to_html().replace('\\n', '') graphData.drop(this_legend, 1, inplace=True) #add the name of the line to the checkbox so that it can be turned off and o line_onOff.labels.append(this_legend) line_onOff.active.append(len(line_onOff.labels) - 1) legendDiv.text = '<div>' for line in lines: legendDiv.text += '<br><div style="background-color: %s; float:up; padding: 4px 4px 4px 4px"></div><br>' % line.glyph.line_color legendDiv.text += '</div>' ##leaving this in case we get around to figuring out the hover tool ##formats the date values for the hover tool, currently commented out until we, or bokeh, fix the hover tool for multiple lines #formDates= pd.to_datetime(graphData['Date'] ,format="%m-%d-%Y") #lines[-1].data_source.data['formDates'] = formDates.apply(lambda x: x.strftime('%m-%d-%Y')) ##Displays the amout of time it took to draw the line, as well as the number of points in the graph updateDebug("updated y vals, with rolling mean calculated") updateDebug( str(datetime.now() - stTime) + " FOR " + str(len(lines[-1].data_source.data['x'])) + " points") else: updateDebug("There's no data to display") del graphData del workingDf #######Link widgets to their associated functions asCls.on_change('value', asClsChange) prod.on_change('value', prodChange) days_back_buttons.on_change('active', days_back_buttonChange) days_back.on_change('value', days_backChange) fixed_date_buttons.on_change('active', fixed_date_buttonChange) fixed_date.on_change('value', fixed_dateChange) rolling_days_buttons.on_change('active', rolling_days_buttonsChange) rolling_days.on_change('value', rolling_daysChange) line_onOff.on_change('active', line_onOffChange) addLine.on_click(grphUpdt) rszButton.on_click(resize) #Formatting fixed_date_box = WidgetBox(fixed_date, fixed_date_buttons) days_back_box = WidgetBox(days_back, days_back_buttons) rolling_days_box = WidgetBox(rolling_days, rolling_days_buttons) widgets = [ asCls, prod, whereFrom, FQslider, days_back_box, fixed_date_box, rolling_days_box, addLine, rszButton, user_message ] plot_w_description = VBox(plot, descriptions, width=700) pwd_w_leg = HBox(plot_w_description, VBox(legendDiv), VBox(line_onOff), width=plot_w_description.width + line_onOff.width + 100, name='div_to_save') input_box = VBox(*widgets, width=400, height=1200) total_box = HBox(VBox(input_box), VBox(pwd_w_leg), width=input_box.width + pwd_w_leg.width + 100, height=1200) tot_w_debug = VBox(total_box, VBox(HBox(debug))) resize() return tot_w_debug
def plot_tsne(self, parameter): result = self.result source1 = column_source(result, 'INACTIVO') source2 = column_source(result, 'PQSR-AGONISTA') source3 = column_source(result, 'RHLR-ANTAGONISTA') source4 = column_source(result, 'LASR-AGONISTA') source5 = column_source(result, 'PQSR-ANTAGONISTA') source6 = column_source(result, 'BIOFACQUIM_V2') source7 = column_source(result, 'LASR-ANTAGONISTA') source8 = column_source(result, 'QUIPRONAB') source9 = column_source(result, 'NuBBE') source10 = column_source(result, 'RHLR-AGONISTA') hover = HoverTool(tooltips=[ ("PCA 1", "$x"), ("PCA 2", "$y"), ("NAME", "@N"), ]) p = figure( title="tSNE based on " + parameter, x_axis_label="PC 1", y_axis_label="PC 2", x_range=(-7, 7), y_range=(-7, 7), tools=[hover], plot_width=1000, plot_height=800, ) p.add_tools(LassoSelectTool(), ZoomInTool(), ZoomOutTool(), SaveTool(), PanTool()) INACTIVO_plot = p.circle(x="x", y="y", source=source1, color="indigo", size=5) PQSR_AGONISTA_plot = p.circle(x="x", y="y", source=source2, color="hotpink", size=5) RHLR_ANTAGONISTA_plot = p.circle(x="x", y="y", source=source3, color="navy", size=5) LASR_AGONISTA_plot = p.circle(x="x", y="y", source=source4, color="dodgerblue", size=5) PQSR_ANTAGONISTA_plot = p.circle(x="x", y="y", source=source5, color="lightcoral", size=5) BIOFACQUIM_V2_plot = p.circle(x="x", y="y", source=source6, color="gold", size=5) LASR_ANTAGONISTA_plot = p.circle(x="x", y="y", source=source7, color="yellowgreen", size=5) QUIPRONAB_plot = p.circle(x="x", y="y", source=source8, color="green", size=5) NuBBE_plot = p.circle(x="x", y="y", source=source9, color="orangered", size=5) RHLR_AGONISTA_plot = p.circle(x="x", y="y", source=source10, color="mediumvioletred", size=5) legend = Legend( items=[ ('INACTIVO', [INACTIVO_plot]), ('PQSR-AGONISTA', [PQSR_AGONISTA_plot]), ('RHLR-ANTAGONISTA', [RHLR_ANTAGONISTA_plot]), ('LASR-AGONISTA', [LASR_AGONISTA_plot]), ('PQSR-ANTAGONISTA', [PQSR_ANTAGONISTA_plot]), ('BIOFACQUIM_V2', [BIOFACQUIM_V2_plot]), ('LASR-ANTAGONISTA', [LASR_ANTAGONISTA_plot]), ('QUIPRONAB', [QUIPRONAB_plot]), ('NuBBE', [NuBBE_plot]), ('RHLR-AGONISTA', [RHLR_AGONISTA_plot]), ], location="center", orientation="vertical", click_policy="hide", ) p.add_layout(legend, place="right") p.xaxis.axis_label_text_font_size = "20pt" p.yaxis.axis_label_text_font_size = "20pt" p.xaxis.axis_label_text_color = "black" p.yaxis.axis_label_text_color = "black" p.xaxis.major_label_text_font_size = "18pt" p.yaxis.major_label_text_font_size = "18pt" p.title.text_font_size = "22pt" show(p)
graph_circle.edge_renderer.glyph.line_width = {'field': 'weight'} graph_circle.edge_renderer.data_source.data['color'] = colors #graph_circle.edge_renderer.glyph.line_color = {'field': 'color'} graph_circle.selection_policy = NodesAndLinkedEdges() graph_circle.inspection_policy = NodesAndLinkedEdges() # !!! Hover the node attributes !!! node_hover = HoverTool(tooltips=[('Name', '@index'), ('Degree', '@degree')]) plot_circle.add_tools(node_hover) plot_circle.add_tools(WheelZoomTool()) plot_circle.add_tools(ResetTool()) plot_circle.add_tools(PanTool()) plot_circle.add_tools(TapTool()) plot_circle.add_tools(SaveTool()) plot_circle.add_tools(BoxSelectTool()) plot_circle.add_tools(LassoSelectTool()) plot_circle.renderers.append(graph_circle) # spring layout plot_spring = Plot(plot_width=1000, plot_height=715, x_range=Range1d(-1.1, 1.1), y_range=Range1d(-1.1, 1.1)) my_points= nx.spring_layout(g, iterations = 50) my_colors = [] for key, value in my_points.items(): #print (key, 'corresponds to', value) #print(' X: ', value[0] )
def __init__(self, nplots, plot_height=350, plot_width=700, lower=0, upper=1000, nbins=100): """Initialize histogram plots. Args: nplots (int): Number of histogram plots that will share common controls. plot_height (int, optional): Height of plot area in screen pixels. Defaults to 350. plot_width (int, optional): Width of plot area in screen pixels. Defaults to 700. lower (int, optional): Initial lower range of the bins. Defaults to 0. upper (int, optional): Initial upper range of the bins. Defaults to 1000. nbins (int, optional): Initial number of the bins. Defaults to 100. """ # Histogram plots self.plots = [] self._plot_sources = [] for ind in range(nplots): plot = Plot( x_range=DataRange1d(), y_range=DataRange1d(), plot_height=plot_height, plot_width=plot_width, toolbar_location="left", ) # ---- tools plot.toolbar.logo = None # share 'pan', 'boxzoom', and 'wheelzoom' tools between all plots if ind == 0: pantool = PanTool() boxzoomtool = BoxZoomTool() wheelzoomtool = WheelZoomTool() plot.add_tools(pantool, boxzoomtool, wheelzoomtool, SaveTool(), ResetTool()) # ---- axes plot.add_layout(LinearAxis(), place="below") plot.add_layout(LinearAxis(major_label_orientation="vertical"), place="left") # ---- grid lines plot.add_layout(Grid(dimension=0, ticker=BasicTicker())) plot.add_layout(Grid(dimension=1, ticker=BasicTicker())) # ---- quad (single bin) glyph plot_source = ColumnDataSource(dict(left=[], right=[], top=[])) plot.add_glyph( plot_source, Quad(left="left", right="right", top="top", bottom=0, fill_color="steelblue"), ) self.plots.append(plot) self._plot_sources.append(plot_source) self._counts = [] self._empty_counts() # Histogram controls # ---- histogram range toggle button def auto_toggle_callback(state): if state: # Automatic lower_spinner.disabled = True upper_spinner.disabled = True else: # Manual lower_spinner.disabled = False upper_spinner.disabled = False auto_toggle = CheckboxGroup(labels=["Auto Hist Range"], active=[0], default_size=145) auto_toggle.on_click(auto_toggle_callback) self.auto_toggle = auto_toggle # ---- histogram lower range def lower_spinner_callback(_attr, _old_value, new_value): self.upper_spinner.low = new_value + STEP self._empty_counts() lower_spinner = Spinner( title="Lower Range:", high=upper - STEP, value=lower, step=STEP, disabled=bool(auto_toggle.active), default_size=145, ) lower_spinner.on_change("value", lower_spinner_callback) self.lower_spinner = lower_spinner # ---- histogram upper range def upper_spinner_callback(_attr, _old_value, new_value): self.lower_spinner.high = new_value - STEP self._empty_counts() upper_spinner = Spinner( title="Upper Range:", low=lower + STEP, value=upper, step=STEP, disabled=bool(auto_toggle.active), default_size=145, ) upper_spinner.on_change("value", upper_spinner_callback) self.upper_spinner = upper_spinner # ---- histogram number of bins def nbins_spinner_callback(_attr, _old_value, _new_value): self._empty_counts() nbins_spinner = Spinner(title="Number of Bins:", low=1, value=nbins, default_size=145) nbins_spinner.on_change("value", nbins_spinner_callback) self.nbins_spinner = nbins_spinner # ---- histogram log10 of counts toggle button def log10counts_toggle_callback(state): self._empty_counts() for plot in self.plots: if state: plot.yaxis[0].axis_label = "log⏨(Counts)" else: plot.yaxis[0].axis_label = "Counts" log10counts_toggle = CheckboxGroup(labels=["log⏨(Counts)"], default_size=145) log10counts_toggle.on_click(log10counts_toggle_callback) self.log10counts_toggle = log10counts_toggle
#make fit visible if dropdown_marker_fit.value!='none': renderers_plot_fit[dropdown_marker_fit.value].visible=True if dropdown_linedash_fit.value=='none': renderers_plot_fit['line'].visible=False else: renderers_plot_fit['line'].visible=True ########################################################################################################################################### ###########################################################plot tab######################################################################## ########################################################################################################################################### ################ #create figure# ############## fig_plot = figure(toolbar_location='right', toolbar_sticky=False, tools=[PanTool(), BoxZoomTool(), WheelZoomTool(), BoxSelectTool(), TapTool(), ResetTool(), SaveTool()],output_backend='webgl') fig_plot.plot_width = 800 fig_plot.plot_height = 600 fig_plot.toolbar.logo = None ############################################################################ #create all selectable renderers and set the circle and line renderer true# ########################################################################## renderers_plot = {rn: getattr(fig_plot, rn)(x='x', y='y', source=source_plot, **extra, visible=False) for rn, extra in [('line', dict(line_width=__linewidth_plot, line_color=__linecolor_plot, line_alpha=__linealpha_plot, line_dash=dict_linedash[__linedash_plot])), ('circle', dict(size=__size_plot, line_width=__linewidth_plot, line_color=__linecolor_plot, fill_color=__fillcolor_plot, line_alpha=__linealpha_plot, fill_alpha=__fillalpha_plot, line_dash=dict_linedash[__linedash_plot])), ('diamond', dict(size=__size_plot, line_width=__linewidth_plot, line_color=__linecolor_plot, fill_color=__fillcolor_plot, line_alpha=__linealpha_plot, fill_alpha=__fillalpha_plot, line_dash=dict_linedash[__linedash_plot])), ('square', dict(size=__size_plot, line_width=__linewidth_plot, line_color=__linecolor_plot, fill_color=__fillcolor_plot, line_alpha=__linealpha_plot, fill_alpha=__fillalpha_plot, line_dash=dict_linedash[__linedash_plot])), ('triangle', dict(size=__size_plot, line_width=__linewidth_plot, line_color=__linecolor_plot, fill_color=__fillcolor_plot, line_alpha=__linealpha_plot, fill_alpha=__fillalpha_plot, line_dash=dict_linedash[__linedash_plot])), ('asterisk', dict(size=__size_plot, line_width=__linewidth_plot, line_color=__linecolor_plot, fill_color=__fillcolor_plot, line_alpha=__linealpha_plot, fill_alpha=__fillalpha_plot, line_dash=dict_linedash[__linedash_plot])),
def make_document(doc): base = "http://192.168.50.62/get?gyrX=%s|gyr_time&gyr_time=%s&gyrY=%s|gyr_time&gyrZ=%s|gyr_time" data = ColumnDataSource( dict( time=[], # display_time=[], x=[], y=[], z=[], )) def get_last(): global current_time # print(current_time) raw = requests.get( base % (current_time, current_time, current_time, current_time)) j = raw.json() ln = min( len(j['buffer']["gyr_time"]["buffer"]), len(j['buffer']["gyrX"]["buffer"]), len(j['buffer']["gyrY"]["buffer"]), len(j['buffer']["gyrZ"]["buffer"]), ) prices_df = pd.DataFrame.from_dict({ "time": j['buffer']["gyr_time"]["buffer"][:ln], "x": j['buffer']["gyrX"]["buffer"][:ln], "y": j['buffer']["gyrY"]["buffer"][:ln], "z": j['buffer']["gyrZ"]["buffer"][:ln], }) if len(j['buffer']["gyr_time"]["buffer"]) == 0: current_time = 0 else: current_time = j['buffer']["gyr_time"]["buffer"][-1] # prices_df["time"] = pd.to_datetime(prices_df["time"], unit="ms") # prices_df["display_time"] = prices_df["time"].dt.strftime("%m-%d-%Y %H:%M:%S.%f") return prices_df def update_price(): new_price = get_last() print(len(new_price['time']), end='\n\n') data.stream( dict(time=new_price["time"], x=new_price["x"], y=new_price["y"], z=new_price["z"]), 1000) return hover = HoverTool( tooltips=[("Time", "@display_time"), ("IEX Real-Time Price", "@price")]) fig_x = figure(plot_width=800, plot_height=400, x_axis_type='datetime', tools=[WheelZoomTool(), ResetTool(), PanTool(), SaveTool()], title="Real-Time Price Plot") fig_x.line(source=data, color="navy", x='time', y='x') fig_x.xaxis.axis_label = "Time" fig_x.yaxis.axis_label = "IEX Real-Time Price" fig_x.title.text = "IEX Real Time Price: " fig_y = figure(plot_width=800, plot_height=400, x_axis_type='datetime', tools=[WheelZoomTool(), ResetTool(), PanTool(), SaveTool()], title="Real-Time Price Plot", x_range=fig_x.x_range, y_range=fig_x.y_range) fig_y.line(source=data, color="navy", x='time', y='y') fig_y.xaxis.axis_label = "Time" fig_y.yaxis.axis_label = "IEX Real-Time Price" fig_y.title.text = "IEX Real Time Price: " fig_z = figure(plot_width=800, plot_height=400, x_axis_type='datetime', tools=[WheelZoomTool(), ResetTool(), PanTool(), SaveTool()], title="Real-Time Price Plot", x_range=fig_x.x_range, y_range=fig_x.y_range) fig_z.line(source=data, color="navy", x='time', y='z') fig_z.xaxis.axis_label = "Time" fig_z.yaxis.axis_label = "IEX Real-Time Price" fig_z.title.text = "IEX Real Time Price: " ticker_textbox = TextInput(placeholder="Ticker") update = Button(label="Update") inputs = widgetbox([ticker_textbox, update], width=200) doc.add_root(column(fig_x, fig_y, fig_z, width=1600)) doc.title = "Real-Time Price Plot from IEX" doc.add_periodic_callback(update_price, 30)
def bokeh_plot(import_df): import pandas as pd import numpy as np from bokeh.plotting import figure, show from bokeh.layouts import layout, widgetbox, row, column, gridplot from bokeh.models import ColumnDataSource, HoverTool, BoxZoomTool, ResetTool, PanTool, CustomJS, PrintfTickFormatter, WheelZoomTool, SaveTool, LassoSelectTool, NumeralTickFormatter from bokeh.models.widgets import Slider, Select, TextInput, Div, Tabs, Panel, DataTable, DateFormatter, TableColumn, PreText, NumberFormatter, RangeSlider from bokeh.io import curdoc from functools import lru_cache from bokeh.transform import dodge from os.path import dirname, join from bokeh.core.properties import value #load plotting data here @lru_cache() def load_data(): df = import_df df.dropna(how='all', axis=0) #Northest=['3229','3277','3276','3230','3259','All_Stores_NE'] df.location_reference_id = df.location_reference_id.astype(str) #df['region'] = ['Northeast' if x in Northest else 'Midwest' for x in df['location_reference_id']] df['date'] = pd.to_datetime(df['date']) df[[ 'BOH_gt_Shelf_Capacity', 'OTL_gt_Shelf_Capacity', 'Ideal_BOH_gt_Shelf_Capacity', 'BOH_lt_Ideal', 'BOH_eq_Ideal', 'BOH_gt_Ideal', 'Demand_Fulfilled', 'Fill_Rate', 'Backroom_OH', 'Total_OH', 'Prop_OH_in_Backroom', 'Never_Q98_gt_POG', 'Never_Ideal_BOH_gt_POG', 'Sometimes_OTL_Casepack_1_gt_POG', 'Always_OTL_Casepack_1_le_POG', 'Non_POG' ]] = df[[ 'BOH > Shelf Capacity', 'OTL > Shelf Capacity', 'Ideal BOH > Shelf Capacity', 'BOH < Ideal', 'BOH = Ideal', 'BOH > Ideal', 'Demand Fulfilled', 'Fill Rate', 'Backroom_OH', 'Total OH', 'Prop OH in Backroom', 'Never: Q98 > POG', 'Never: Ideal BOH > POG', 'Sometimes: OTL+Casepack-1 > POG', 'Always: OTL+Casepack-1 <= POG', 'Non-POG' ]] df['date_bar'] = df['date'] df['date_bar'] = df['date_bar'].astype(str) return df #Filter data source for "All" stores OR data agrregation on DC level df_agg = load_data().groupby(['location_reference_id'], as_index=False).sum() source1 = ColumnDataSource(data=df_agg) sdate = min(load_data()['date']) edate = max(load_data()['date']) nodes = len(list(load_data().location_reference_id.unique())) days = len(list(load_data().date.unique())) policy = "Prod" #list of dates for vbar charts x_range_list = list(load_data().date_bar.unique()) #direct access to number of location_reference_idand region all_locations1 = list(load_data().location_reference_id.unique()) #agg_value=['All'] #all location_reference_idfrom csv file along with an option for agg data "All" #all_locations=all_locations1+agg_value #all_regions = ['Northeast', 'Midwest'] all_regions = list(load_data().region.unique()) desc = Div(text="All locations", width=230) pre = Div(text="_", width=230) location = Select(title="Location", options=all_locations1, value="All_Stores_NE") region = Select(title="Region", options=all_regions, value="NE") text_input = TextInput(value="default", title="Search Location:") #full data set from load_data(df=df_import) source = ColumnDataSource(data=load_data()) original_source = ColumnDataSource(data=load_data()) #plotting starts........... here are total 8 graphs for each Metric. #Back room on hand hover = HoverTool( tooltips=[("Location", "@location_reference_id"), ( "Date", "@date_bar"), ("Backroom_OH", "@Backroom_OH{0,0.00}")]) TOOLS = [ hover, BoxZoomTool(), LassoSelectTool(), WheelZoomTool(), PanTool(), ResetTool(), SaveTool() ] p = figure(x_range=x_range_list, plot_width=1000, plot_height=525, title="Backroom On hand by store", tools=TOOLS, toolbar_location='above', x_axis_label="Date", y_axis_label="Backroom OH") p.background_fill_color = "#e6e9ed" p.background_fill_alpha = 0.5 p.vbar(x=dodge('date_bar', -0.25, range=p.x_range), top='Backroom_OH', hover_alpha=0.5, hover_line_color='black', width=0.8, source=source, color="#718dbf") p.xaxis.major_label_orientation = 1 p.legend.border_line_width = 3 p.legend.border_line_color = None p.legend.border_line_alpha = 0.5 p.title.text_color = "olive" #inbound outbound hover_m = HoverTool( tooltips=[("Location", "@location_reference_id"), ( "Date", "@date_bar"), ( "Inbound", "@Inbound{0,0.00}"), ("Outbound", "@Outbound{0,0.00}")]) TOOLS_m = [ hover_m, BoxZoomTool(), LassoSelectTool(), WheelZoomTool(), PanTool(), ResetTool(), SaveTool() ] m = figure(plot_height=525, plot_width=1000, x_range=x_range_list, title="Inbound/Outbound by store", tools=TOOLS_m, toolbar_location='above', x_axis_label="Date", y_axis_label="Units") m.background_fill_color = "#e6e9ed" m.background_fill_alpha = 0.5 m.vbar(x=dodge('date_bar', -0.25, range=m.x_range), top='Inbound', hover_alpha=0.5, hover_line_color='black', width=0.4, source=source, color="#718dbf", legend=value("Inbound")) m.vbar(x=dodge('date_bar', 0.25, range=m.x_range), top='Outbound', hover_alpha=0.5, hover_line_color='black', width=0.4, source=source, color="#e84d60", legend=value("Outbound")) m.xaxis.major_label_orientation = 1 m.legend.border_line_width = 3 m.legend.border_line_color = None m.legend.border_line_alpha = 0.5 m.title.text_color = "olive" #Stockout hover_s = HoverTool( tooltips=[("Location", "@location_reference_id"), ( "Date", "@date_bar"), ( "BOH_OOS", "@BOH_OOS{0,0.000}"), ("EOH_OOS", "@EOH_OOS{0,0.000}")]) TOOLS_s = [ hover_s, BoxZoomTool(), LassoSelectTool(), WheelZoomTool(), PanTool(), ResetTool(), SaveTool() ] s = figure(plot_height=525, plot_width=1000, title="Stockouts by store", x_axis_type="datetime", toolbar_location='above', tools=TOOLS_s, x_axis_label="Date", y_axis_label="Prop Stockout") s.background_fill_color = "#e6e9ed" s.background_fill_alpha = 0.5 s.circle(x='date', y='EOH_OOS', source=source, fill_color=None, line_color="#4375c6") s.line(x='date', y='EOH_OOS', source=source, hover_alpha=0.5, hover_line_color='black', line_width=2, line_color='navy', legend=value("EOH OOS")) s.circle(x='date', y='BOH_OOS', source=source, fill_color=None, line_color="#4375c6") s.line(x='date', y='BOH_OOS', source=source, hover_alpha=0.5, hover_line_color='black', line_width=2, line_color='red', legend=value("BOH OOS")) s.legend.border_line_width = 3 s.legend.border_line_color = None s.legend.border_line_alpha = 0.5 s.title.text_color = "olive" #Fill rate hover_t = HoverTool( tooltips=[("Location", "@location_reference_id"), ( "Date", "@date_bar"), ("Fill Rate", "@Fill_Rate{0,0.00}")]) TOOLS_t = [ hover_t, BoxZoomTool(), LassoSelectTool(), WheelZoomTool(), PanTool(), ResetTool(), SaveTool() ] t = figure(plot_height=525, x_range=x_range_list, plot_width=1000, title="Fill rates by store", tools=TOOLS_t, toolbar_location='above', x_axis_label="Date", y_axis_label="Fill rate") t.background_fill_color = "#e6e9ed" t.background_fill_alpha = 0.5 t.vbar(x=dodge('date_bar', -0.25, range=t.x_range), top='Fill Rate', hover_alpha=0.5, hover_line_color='black', width=0.8, source=source, color="#718dbf") t.xaxis.major_label_orientation = 1 t.legend.border_line_width = 3 t.legend.border_line_color = None t.legend.border_line_alpha = 0.5 t.title.text_color = "olive" # % Backroom spillover hover_w = HoverTool( tooltips=[("Location", "@location_reference_id"), ("Date", "@date_bar"), ("Prop OH in Backroom", "@Prop_OH_in_Backroom{0,0.00}")]) TOOLS_w = [ hover_w, BoxZoomTool(), LassoSelectTool(), WheelZoomTool(), PanTool(), ResetTool(), SaveTool() ] w = figure(plot_height=525, plot_width=1000, title="Prop OH in Backroom by store", x_axis_type="datetime", tools=TOOLS_w, toolbar_location='above', x_axis_label="Date", y_axis_label=" % Backroom spillover") w.background_fill_color = "#e6e9ed" w.background_fill_alpha = 0.5 w.circle(x='date', y='Prop OH in Backroom', source=source, fill_color=None, line_color="#4375c6") w.line(x='date', y='Prop OH in Backroom', source=source, hover_alpha=0.5, hover_line_color='black', line_width=2, line_color='navy') w.title.text_font_style = "bold" w.title.text_color = "olive" w.legend.click_policy = "hide" w.yaxis[0].formatter = NumeralTickFormatter(format="0.0%") #BOH vs Ideal hover_f = HoverTool( tooltips=[("Location", "@location_reference_id"), ( "Date", "@date_bar"), ('BOH < Ideal', "@BOH_lt_Ideal{0,0.00}" ), ('BOH > Ideal', "@BOH_gt_Ideal{0,0.00}" ), ('BOH = Ideal', "@BOH_eq_Ideal{0,0.00}")]) TOOLS_f = [ hover_f, BoxZoomTool(), LassoSelectTool(), WheelZoomTool(), PanTool(), ResetTool(), SaveTool() ] colors = ["#c9d9d3", "#718dbf", "#e84d60"] BOH_vs_ideal = ['BOH < Ideal', 'BOH > Ideal', 'BOH = Ideal'] f = figure(x_range=x_range_list, plot_height=525, plot_width=1000, title="BOH vs Ideal by store", toolbar_location='above', x_axis_label="Date", y_axis_label="Prop", tools=TOOLS_f) f.vbar_stack(BOH_vs_ideal, x='date_bar', width=0.9, color=colors, source=source, legend=[value(x) for x in BOH_vs_ideal], name=BOH_vs_ideal) f.xaxis.major_label_orientation = 1 f.legend.border_line_width = 3 f.legend.border_line_color = None f.legend.border_line_alpha = 0.5 f.title.text_color = "olive" #Pog Fit hover_g = HoverTool( tooltips=[("Location", "@location_reference_id"), ( "Date", "@date_bar"), ('Never: Q98 > POG', "@Never_Q98_gt_POG{0,0.00}"), ("Never: Ideal BOH > POG", "@Never_Ideal_BOH_gt_POG{0,0.00}"), ("Sometimes: OTL+Casepack-1 > POG", "@Sometimes_OTL_Casepack_1_gt_POG{0,0.00}"), ("Always: OTL+Casepack-1 <= POG", "@Always_OTL_Casepack_1_le_POG{0,0.00}" ), ("Non-POG'", "@Non_POG{0,0.00}")]) TOOLS_g = [ hover_g, BoxZoomTool(), LassoSelectTool(), WheelZoomTool(), PanTool(), ResetTool(), SaveTool() ] colors2 = ['#79D151', "#718dbf", '#29788E', '#fc8d59', '#d53e4f'] pog_fit = [ 'Never: Q98 > POG', 'Never: Ideal BOH > POG', 'Sometimes: OTL+Casepack-1 > POG', 'Always: OTL+Casepack-1 <= POG', 'Non-POG' ] g = figure(x_range=x_range_list, plot_height=525, plot_width=1200, title="Pog Fit by store", toolbar_location='above', x_axis_label="Date", y_axis_label="Counts", tools=TOOLS_g) g.vbar_stack(pog_fit, x='date_bar', width=0.9, color=colors2, source=source, legend=[value(x) for x in pog_fit], name=pog_fit) g.xaxis.major_label_orientation = 1 g.legend.border_line_width = 3 g.legend.border_line_color = None g.legend.border_line_alpha = 0.5 g.title.text_color = "olive" g.legend.location = "top_right" # BOH vs Pog colors3 = ["#c9d9d3", "#718dbf", "#e84d60"] shelf = [ 'BOH > Shelf Capacity', 'OTL > Shelf Capacity', 'Ideal BOH > Shelf Capacity' ] hover_h = HoverTool( tooltips=[("Location", "@location_reference_id"), ("Date", "@date_bar"), ("OTL > Shelf Capacity", "@OTL_gt_Shelf_Capacity{0,0.00}" ), ("BOH > Shelf Capacity", "@BOH_gt_Shelf_Capacity{0,0.00}"), ("Ideal BOH > Shelf Capacity", "@Ideal_BOH_gt_Shelf_Capacity{0,0.00}")]) TOOLS_h = [ hover_h, BoxZoomTool(), LassoSelectTool(), WheelZoomTool(), PanTool(), ResetTool(), SaveTool() ] h = figure(plot_height=525, plot_width=1000, title="BOH vs Pog by store", x_axis_type="datetime", toolbar_location='above', tools=TOOLS_h, x_axis_label="Date", y_axis_label="Prop") h.background_fill_color = "#e6e9ed" h.background_fill_alpha = 0.5 h.circle(x='date', y='BOH > Shelf Capacity', source=source, fill_color=None, line_color="#4375c6") h.line(x='date', y='BOH > Shelf Capacity', source=source, hover_alpha=0.5, hover_line_color='black', line_width=2, line_color='navy', legend=value("BOH > Shelf Capacity")) h.circle(x='date', y='OTL > Shelf Capacity', source=source, fill_color=None, line_color="#4375c6") h.line(x='date', y='OTL > Shelf Capacity', source=source, hover_alpha=0.5, hover_line_color='black', line_width=2, line_color="green", legend=value("OTL > Shelf Capacity")) h.circle(x='date', y='Ideal BOH > Shelf Capacity', source=source, fill_color=None, line_color="#4375c6") h.line(x='date', y='Ideal BOH > Shelf Capacity', source=source, hover_alpha=0.5, hover_line_color='black', line_width=2, line_color="#e84d60", legend=value("Ideal BOH > Shelf Capacity")) h.legend.border_line_width = 3 h.legend.border_line_color = None h.legend.border_line_alpha = 0.5 h.title.text_color = "olive" h.legend.click_policy = "mute" # Inventory hover_j = HoverTool( tooltips=[("Location", "@location_reference_id"), ( "Date", "@date_bar"), ("DFE_Q98", "@DFE_Q98{0,0.00}"), ("OTL", "@OTL{0,0.00}"), ("EOH", "@EOH{0,0.00}"), ("BOH", "@BOH{0,0.00}")]) TOOLS_j = [ hover_j, BoxZoomTool(), LassoSelectTool(), WheelZoomTool(), PanTool(), ResetTool(), SaveTool() ] j = figure(plot_height=525, plot_width=1200, x_range=x_range_list, title="Inbound/Outbound by store", tools=TOOLS_j, toolbar_location='above', x_axis_label="Date", y_axis_label="Units") j.background_fill_color = "#e6e9ed" j.background_fill_alpha = 0.5 j.vbar(x=dodge('date_bar', -0.40, range=j.x_range), top='DFE_Q98', hover_alpha=0.3, hover_line_color='black', width=0.2, source=source, color="#FBA40A", legend=value("DFE_Q98")) j.vbar(x=dodge('date_bar', -0.20, range=j.x_range), top='OTL', hover_alpha=0.3, hover_line_color='black', width=0.2, source=source, color="#4292c6", legend=value("OTL")) j.vbar(x=dodge('date_bar', 0.00, range=j.x_range), top='EOH', hover_alpha=0.3, hover_line_color='black', width=0.2, source=source, color='#a1dab4', legend=value("EOH")) j.vbar(x=dodge('date_bar', 0.20, range=j.x_range), top='BOH', hover_alpha=0.3, hover_line_color='black', width=0.2, source=source, color="#DC5039", legend=value("BOH")) j.xaxis.major_label_orientation = 1 j.legend.border_line_width = 3 j.legend.border_line_color = None j.legend.border_line_alpha = 0.5 j.title.text_color = "olive" j.legend.location = "top_left" j.legend.click_policy = "mute" #desc.text = " <br > <b> Region:</b> <i> </i> <br /> " pre.text = " <b>Start date:</b> <i>{}</i> <br /> <b>End date:</b> <i>{}</i> <br /> <b>Time period:</b> <i>{}</i> days <br /> <b> Total Number of Nodes:</b> <i>{}</i> <br /> <b>Policy</b> = <i>{}</i><br /> ".format( sdate, edate, days, nodes, policy) #fuction to update data on selection callback = CustomJS(args=dict(source=source, original_source=original_source, location_select_obj=location, region_select_obj=region, div=desc, text_input=text_input), code=""" var data = source.get('data'); var original_data = original_source.get('data'); var loc = location_select_obj.get('value'); var reg = region_select_obj.get('value'); var line = " <br /> <b> Region:</b>"+ reg + "<br /> <b>Location:</b> " + loc; var text_input =text_input.get('value'); div.text=line; for (var key in original_data) { data[key] = []; for (var i = 0; i < original_data['location_reference_id'].length; ++i) { if ((original_data['location_reference_id'][i] === loc) && (original_data['region'][i] === reg) ) { data[key].push(original_data[key][i]); } } } source.trigger('change'); """) #controls = [location, region] #for control in controls: #control.js_on_change("value", callback) #source.js_on_change("value", callback) desc.js_on_event('event', callback) location.js_on_change('value', callback) region.js_on_change('value', callback) text_input.js_on_change('value', callback) #inputs = widgetbox(*controls, sizing_mode="fixed") #inputs = widgetbox(*controls,width=220,height=500) inputs = widgetbox(location, region, desc, pre, width=220, height=500) # controls number of tabs tab1 = Panel(child=p, title='Backroom OH') tab2 = Panel(child=s, title='Stockouts') tab3 = Panel(child=f, title='BOH vs Ideal') tab4 = Panel(child=g, title='Pog Fit') tab5 = Panel(child=m, title='Inbound/Outbound') tab6 = Panel(child=h, title='BOH vs POG') tab7 = Panel(child=t, title='Fill Rate') tab8 = Panel(child=j, title='Inventory') tab9 = Panel(child=w, title='Prop OH in Backroom') #data table columns to summarize data columns = [ TableColumn(field="location_reference_id", title="Location"), TableColumn(field="Backroom_OH", title="Backroom_OH", formatter=NumberFormatter(format="0,0")), TableColumn(field="Outbound", title="Outbound", formatter=NumberFormatter(format="0,0")), TableColumn(field="Inbound", title="Inbound", formatter=NumberFormatter(format="0,0")), TableColumn(field="OTL", title="OTL", formatter=NumberFormatter(format="0,0")), TableColumn(field="DFE_Q98", title="DFE_Q98", formatter=NumberFormatter(format="0,0")), TableColumn(field="BOH", title="BOH", formatter=NumberFormatter(format="0,0")), TableColumn(field="EOH", title="EOH", formatter=NumberFormatter(format="0,0")), TableColumn(field="BOH_OOS", title="BOH_OOS", formatter=NumberFormatter(format="0,0")), TableColumn(field="EOH_OOS", title="EOH_OOS", formatter=NumberFormatter(format="0,0")) ] data_table = DataTable(source=source1, columns=columns, width=1250) tab10 = Panel(child=data_table, title='Summary Table') view = Tabs( tabs=[tab1, tab2, tab5, tab8, tab6, tab3, tab7, tab4, tab9, tab10]) layout_text = column(inputs) layout1 = row(layout_text, view) #laying out plot layout2 = layout(children=[[layout_text, view]], sizing_mode='scale_height') #update plots return layout2
def main(): """Invoke when run directly as a program.""" args = parse_arguments() df = pd.read_csv(args.infile, sep=r"\s+", names=["amplicon", "meancov", "gene"]) df["offsetcov"] = df["meancov"] + 0.1 # shift zero values by 0.1 df = df.dropna().reset_index(drop=True) # Make a hover (show amplicon name on mouse-over) hover = HoverTool(tooltips=[("Amplicon", "@names"), ("Y value", "$y")]) tools = [ PanTool(), BoxZoomTool(), WheelZoomTool(), RedoTool(), UndoTool(), ResetTool(), hover, SaveTool(), ] # Produce plot output_file(args.outfile) fig = figure(tools=tools, width=1200, height=600, y_axis_type="log") # Fill plot with one point for each amplicon: xvals, yvals, labels, colors = [], [], [], [] for i, (name, group) in enumerate(df.groupby("gene", sort=False)): xvals.extend(list(group.index)) yvals.extend(list(group.offsetcov)) labels.extend(list(group.amplicon)) # Elements in the same group should have the same color. Cycle between colors in COLOR_CYCLE: colors.extend([COLOR_CYCLE[i % len(COLOR_CYCLE)]] * len(list(group.index))) data = ColumnDataSource(data=dict(x=xvals, y=yvals, names=labels, colors=colors)) fig.circle(x="x", y="y", color="colors", size=10, source=data) # Make span lines on 0.05, 0.1, 0.2, 1 and 5 mutiples of mean amplicon coverage: mean_coverage = df.offsetcov.mean() span_lines = [ (5.0, "Blue"), (1.0, "Green"), (0.2, "Red"), (0.1, "Purple"), (0.05, "Magenta"), ] xmin, xmax = min(xvals) - 1, max(xvals) + 1 for ratio, color in span_lines: fig.line( [xmin, xmax], [mean_coverage * ratio] * 2, line_color=color, line_dash="dashed", legend="{:.0f} % of mean coverage".format(ratio * 100), ) # Customize plot: ymax = 2.0 * max(df.offsetcov.max() + 1000, mean_coverage * 5) ymin = 0.2 fig.y_range = Range1d(ymin, ymax) fig.x_range = Range1d(xmin, xmax) fig.xaxis.major_tick_line_color = None # Turn off x-axis major ticks fig.xaxis.minor_tick_line_color = None # Turn off x-axis minor ticks fig.xaxis.major_label_text_font_size = "0pt" # Hack to remove tick labels fig.xaxis.axis_label = "Amplicon" fig.yaxis.axis_label = "Log10 (Amplicon coverage)" fig.legend.location = "bottom_right" script, div = components(layouts.row(fig)) with open(os.path.join(os.path.dirname(args.outfile), "plot.js"), "wt") as jfile: jfile.write("\n".join(script.split("\n")[2:-1])) with open(args.outfile, "wt") as ofile: env = Environment(loader=FileSystemLoader(os.path.dirname(args.template))) page_template = env.get_template(os.path.basename(args.template)) html_text = page_template.render({"bokeh_div": div}) ofile.write(html_text)
# Definition of the protocol values and their actual names protocols_path = "{}doc/protocols".format(potiron_path) protocols = potiron.define_protocols(protocols_path) # Define the strings used for legends, titles, etc. concerning fields field_string, field_in_file_name = field2string(field, potiron_path) field_data = create_dict(field, potiron_path) # Creation of the figure and the tools used on it namefile=output_name(source,field_in_file_name,fieldvalues,date,outputdir) output_file("{}.html".format(namefile), title=namefile.split("/")[-1]) hover = HoverTool(tooltips = [('count','@y'),('protocol','@protocol')]) taptool = TapTool() TOOLS = [hover,PanTool(),BoxZoomTool(),WheelZoomTool(), taptool, SaveTool(), ResetTool()] p = figure(width=plot_width,height=plot_height,tools=TOOLS) # Definition of some variables which will be used and modified with the iterations at_least_one = False days = calendar.monthrange(int(date[0:4]),int(date[4:6]))[1] maxVal = 0 minVal = sys.maxsize maxDay = 0 vlength = len(fieldvalues) actual_values = [] nbLine = 0 # For each selected field or occurrence for v in range(vlength): value = fieldvalues[v].split('-') actual_field = value[0] #
def dashboard(df, sim_time=180, lat=43.223628, lon=-90.294633, outfile='dashboard.html'): #Isolate the individual housing states df_onlyState = df[[ 'inspection_get', 'claim_get', 'fema_get', 'sba_get', 'permit_get', 'repair_get', 'home_get', 'occupy_get' ]] #list of statuses in correct order for future reference statuses = [ 'inspection_get', 'claim_get', 'fema_get', 'sba_get', 'permit_get', 'repair_get', 'home_get', 'occupy_get' ] NUM_HOMES = df.shape[0] #the total number of entities NUM_CAT = len(statuses) #the total number of categories # assign colors to the sequential housing statuses. # colors are map-optimised, from ColorBrewer # palettes will scale to size automatically, max size is 20 colors_only = bokeh.palettes.d3['Category20'][NUM_CAT] colors = {} for i in range(0, len(statuses)): colors[statuses[i]] = colors_only[i] # create a list to hold the status of all homes by day home_status_list = [] for i in range(0, sim_time): single_home_status = np.empty(shape=[2860, 1], dtype=object) curr_max = i curr = 0 for row in df_onlyState.itertuples(index=False): #convert the row into a dictionary for key-value analysis row_asDict = row._asdict() #find the most recent status time of the home within currMax. ignores None and nan try: mostRecentTime = max(value for name, value in row_asDict.items() if value is not None and value < curr_max) #reverse key-value to determine actual status key = next(key for key, value in row_asDict.items() if value == mostRecentTime) except ValueError: key = 'no_status' single_home_status[curr] = key curr += 1 home_status_list.append( pd.Series(data=single_home_status.ravel(), name=i)) # create a single DataFrame for the home statuses at every unit of simulation time home_status = pd.concat(home_status_list, axis=1) # dataframe for number of homes with a given status at every point of simulation time status_count_list = [] for time in range(0, sim_time): status_count_list.append( pd.Series(data=home_status[time].value_counts(), name=str(time))) #concatenate and fill NaN with zeroes. re-index rows to correct order status_count_df = pd.concat(status_count_list, axis=1).fillna(value=0).reindex(statuses) #create a new dataframe with just the colors for the map #current colors: white to dark green, where dark green = home_get home_status_colors = home_status.replace(colors) # Interactive Barplot # Standalone HTML file using CustomJS #wrangle the data into a data source for the ColumnDataSource to work properly with Javascript per_day = status_count_df.transpose().values.tolist() data = dict({str(i): v for i, v in enumerate(per_day)}) data['x'] = statuses #add the statuses to the data source data['y'] = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] #dummy column for CustomJS to overwrite data['colors'] = colors_only source = ColumnDataSource(data) output_file(outfile) #plot setup barplot = figure( plot_width=800, plot_height=600, tools='pan, wheel_zoom, reset, save', x_axis_label='Status', x_range=source.data['x'], y_range=ranges.Range1d(start=0, end=len(data['y'])), title="Number of Households by Status at Specified Time (Slider)") barplot.vbar(source=source, x='x', top='y', color='colors', width=0.6) bar_hover = HoverTool(tooltips=[('num', '@y')]) barplot.add_tools(bar_hover) lat = 43.223628 lon = -90.294633 #Map Setup map_options = GMapOptions(lat=lat, lng=lon, scale_control=True, map_type="roadmap", zoom=16) mapplot = GMapPlot(x_range=Range1d(), y_range=Range1d(), map_options=map_options) mapplot.title.text = "Locations of Modeled Homes (Marker Size Proportional to Original Damage State; Colors Defined Below)" # Set up tool tip with household stories hover = HoverTool() hover.tooltips = [("Household's Story:", "@story")] mapplot.add_tools(PanTool(), WheelZoomTool(), ResetTool(), hover, SaveTool()) mapplot.min_border_top = 50 mapplot.min_border_bottom = 0 #set Google Maps API key mapplot.api_key = "AIzaSyDedFXgNZ71_xOGmVE_eAhElFJOuVweB1Y" #data wrangling for JS interaction home_status_formap = pd.concat( [home_status_colors.copy(), df['latitude'], df['longitude']], axis=1) home_status_formap['y'] = np.nan #dummy column home_status_formap['story'] = df['story'] home_status_formap.columns = home_status_formap.columns.astype(str) # Reclassify damage states at start of simulation for each household to set # marker/circle size for mapping damage_size = dict({ 'None': 10, 'Slight': 15, 'Moderate': 20, 'Extensive': 25, 'Complete': 30 }) home_status_formap['circle_size'] = df['damage_state_start'].replace( list(damage_size.keys()), list(damage_size.values())) mapsource = ColumnDataSource(home_status_formap) circle = Circle(x="longitude", y="latitude", size='circle_size', fill_color="y", fill_alpha=0.8, line_color='black') mapplot.add_glyph(mapsource, circle) # Javascript callback to enable and link interactivity between the two plots. callback = CustomJS(args=dict(s1=source, s2=mapsource), code=""" console.log(' changed selected time', cb_obj.value); var data = s1.data; var data2 = s2.data; data['y'] = data[cb_obj.value]; data2['y'] = data2[cb_obj.value]; s1.change.emit() s2.change.emit() """) #Line Graph setup line_plot = figure( title='Number of Households By Status vs. Simulated Time', y_range=ranges.Range1d(start=int(NUM_HOMES * 0.1), end=int(NUM_HOMES * 1.5)), tools='pan, wheel_zoom, reset, save') all_line_data = status_count_df.values.tolist() day_range = np.linspace(0, sim_time, num=sim_time).tolist() # Generate a vertical bar to indicate current time within the line graph # Line is generated to 10% above the number of homes and 10% below zero currtime_list = { 'x': [0, 0], 'y': [int(NUM_HOMES * 1.1), int(NUM_HOMES * -0.1)] } #dummy column for js callback for i in range(0, sim_time): currtime_list[str(i)] = [i, i] currtime_source = ColumnDataSource(currtime_list) # Create set of line plots with ability to turn individual lines on/off for data, name, color in zip(all_line_data, statuses, colors_only): line_data = pd.DataFrame(data).values.tolist() line_plot.line(day_range, line_data, color=color, alpha=0.8, legend=name, line_width=2) line_plot.line(x='x', y='y', source=currtime_source, line_color='red') line_plot.legend.location = "top_left" line_plot.legend.click_policy = "hide" # Requires Bokeh 0.12.7 # Javascript callback to enable and link interactivity between the two plots. callback = CustomJS(args=dict(s1=source, s2=mapsource, s3=currtime_source), code=""" console.log(' changed selected time', cb_obj.value); var data = s1.data; var data2 = s2.data; var data3 = s3.data; data['y'] = data[cb_obj.value]; data2['y'] = data2[cb_obj.value]; data3['x'] = data3[cb_obj.value]; s1.change.emit(); s2.change.emit(); s3.change.emit(); """) #slider time_slider = Slider(start=0, end=sim_time, value=0, step=1, callback=callback, title='DAY') #show entire layout show( layout([[mapplot], [line_plot, barplot], time_slider], sizing_mode='stretch_both'))
def drawgraph(self, ds, filterMin, filterMax, layout): G = nx.Graph() # create an empty graph with no nodes and no edges # nodes = [] # for i in range(len(ds.getNodes())): # nodes.append([]) # # print(ds.getNodes()[i].getName()) # for j in range(len(ds.getNodes())): # nodes[i].append(ds.getNodes()[i].getLinks()[j][1]) # # print(" " + str(ds.getNodes()[i].getLinks()[j][1])) # ds.toMinSpanTree() nodes = ds.getDoubleList(filterMin, filterMax, False) x = filterMin adj = np.array(nodes) G = nx.from_numpy_matrix(adj) for i in range(len(G.node)): G.node[i]['name'] = ds.getNames()[i] #pos = nx.drawing.layout.circular_layout(G, 1, None, 2) #nx.draw_networkx(G, pos, with_labels=True) # pt.show() #plt.show() plot = Plot(plot_width=500, plot_height=500, x_range=Range1d(-1.1, 1.1), y_range=Range1d(-1.1, 1.1)) node_hover_tool = HoverTool(tooltips=[("Name of this node", "@name")]) # plot.add_tools(node_hover_tool, BoxZoomTool(), ResetTool()) plot.add_tools(node_hover_tool, TapTool(), BoxSelectTool(), BoxZoomTool(), UndoTool(), RedoTool(), SaveTool(), ResetTool()) plot.toolbar_location = 'left' if layout == 0: graph_renderer = from_networkx(G, nx.circular_layout, scale=1, center=(0, 0)) elif layout == 1: graph_renderer = from_networkx(G, nx.spring_layout, scale=1, center=(0, 0)) else: graph_renderer = from_networkx(G, nx.random_layout) graph_renderer.node_renderer.glyph = Circle(size=15, fill_color=Spectral4[0]) graph_renderer.node_renderer.selection_glyph = Circle(size=15, fill_color=Spectral4[2]) graph_renderer.node_renderer.hover_glyph = Circle(size=15, fill_color=Spectral4[1]) graph_renderer.edge_renderer.glyph = MultiLine(line_color="#CCCCCC", line_alpha=0.8, line_width=5) graph_renderer.edge_renderer.selection_glyph = MultiLine(line_color=Spectral4[2], line_width=5) graph_renderer.edge_renderer.hover_glyph = MultiLine(line_color=Spectral4[1], line_width=5) graph_renderer.selection_policy = NodesAndLinkedEdges() #graph_renderer.inspection_policy = EdgesAndLinkedNodes() plot.renderers.append(graph_renderer) output_file("interactive_graphs.html") return plot
x_range=xdr, y_range=ydr, plot_width=1000, plot_height=600, min_border=0, toolbar_location=None, background_fill_color='#F0F0F0', border_fill_color='lightgray', ) line_glyph = Line(x="x", y="y", line_color="navy", line_width=2, line_dash="dashed") line = plot.add_glyph(source, line_glyph) circle = Circle(x="x", y="y2", size=6, line_color="red", fill_color="orange", fill_alpha=0.6) circle = plot.add_glyph(source, circle) pan = PanTool() wheel_zoom = WheelZoomTool() preview_save = SaveTool() plot.add_tools(pan, wheel_zoom, preview_save) # Add axes (Note it's important to add these before adding legends in side panels) plot.add_layout(LinearAxis(), 'below') plot.add_layout(LinearAxis(), 'left') plot.add_layout(LinearAxis(), 'right') def add_legend(location, orientation, side): legend = Legend( # TODO: title items=[("line", [line]), ("circle", [circle])], location=location, orientation=orientation, border_line_color="black", )
def generate_graph(self): """ Generate the graph; return a 2-tuple of strings, script to place in the head of the HTML document and div content for the graph itself. :return: 2-tuple (script, div) :rtype: tuple """ logger.debug('Generating graph for %s', self._graph_id) # tools to use tools = [ PanTool(), BoxZoomTool(), WheelZoomTool(), SaveTool(), ResetTool(), ResizeTool() ] # generate the stacked area graph try: g = Area( self._data, x='Date', y=self._y_series_names, title=self._title, stack=True, xlabel='Date', ylabel='Downloads', tools=tools, # note the width and height will be set by JavaScript plot_height=400, plot_width=800, toolbar_location='above', legend=False ) except Exception as ex: logger.error("Error generating %s graph", self._graph_id) logger.error("Data: %s", self._data) logger.error("y=%s", self._y_series_names) raise ex lines = [] legend_parts = [] # add a line at the top of each Patch (stacked area) for hovertool for renderer in g.select(GlyphRenderer): if not isinstance(renderer.glyph, Patches): continue series_name = renderer.data_source.data['series'][0] logger.debug('Adding line for Patches %s (series: %s)', renderer, series_name) line = self._line_for_patches(self._data, g, renderer, series_name) if line is not None: lines.append(line) legend_parts.append((series_name, [line])) # add the Hovertool, specifying only our line glyphs g.add_tools( HoverTool( tooltips=[ (self._y_name, '@SeriesName'), ('Date', '@FmtDate'), ('Downloads', '@Downloads'), ], renderers=lines, line_policy='nearest' ) ) # legend outside chart area legend = Legend(legends=legend_parts, location=(0, 0)) g.add_layout(legend, 'right') return components(g)
def body_figs(data, height=500, width=1000): #Data setup data['date_str'] = data['date'].map(str) ma_cds_working = ColumnDataSource(dict(date=data['date'], date_str=data['date_str'], bpm=data['bpm'], hrv=data['hrv'], scaled_hrv=data['scaled_hrv'], sleep_overall_q=data['sleep_overall_q'], sleep_onset=data['sleep_onset'], sleep_duration=data['sleep_duration'], sleep_how_much_more=data['sleep_how_much_more'], sleep_how_deep=data['sleep_how_deep'], sleep_interruptions=data['sleep_interruptions'], glucose=data['glucose'], ketones=data['ketones'], weight=data['weight'], bodyfat=data['bodyfat'])) ma_cds_static = ColumnDataSource(dict(date=data['date'], date_str=data['date_str'], bpm=data['bpm'], hrv=data['hrv'], scaled_hrv=data['scaled_hrv'], sleep_overall_q=data['sleep_overall_q'], sleep_onset=data['sleep_onset'], sleep_duration=data['sleep_duration'], sleep_how_much_more=data['sleep_how_much_more'], sleep_how_deep=data['sleep_how_deep'], sleep_interruptions=data['sleep_interruptions'], glucose=data['glucose'], ketones=data['ketones'], weight=data['weight'], bodyfat=data['bodyfat'])) #Plot tools configuration wz = WheelZoomTool(dimensions='width') plt_biomarkers_tools = [HoverTool(tooltips=[("Date", "@date_str"), ("RHR", "@bpm{0,0} bpm"), ("Sleep Q", "@sleep_overall_q"), ("Glucose", "@glucose{0,0} mg/dl"), ("Ketones", "@ketones{1.11} mmol/L")],names=["bpm", "glucose"],mode='vline'), PanTool(dimensions='width'), wz, ResetTool(), SaveTool()] wz2 = WheelZoomTool(dimensions='width') plt_bcomp_tools = [HoverTool(tooltips=[("Date", "@date_str"), ("Weight", "@weight{1.1} lbs"), ("BF", "@bodyfat{1.1}%")],mode='vline'), PanTool(dimensions='width'), wz2, ResetTool(), SaveTool()] wz3 = WheelZoomTool(dimensions='width') plt_sleep_tools = [HoverTool(tooltips=[("Date", "@date_str"),("Sleep Quality", "@sleep_overall_q"),("Duration", "@sleep_duration"),("Satisfaction", "@sleep_how_much_more"),("Depth", "@sleep_how_deep"),("Interruptions", "@sleep_interruptions")],names=["sleep_overall_q"],mode='vline'), PanTool(dimensions='width'), wz3, ResetTool(), SaveTool()] #Plot Blood (glucose and ketones) plot_blood = figure(x_axis_type="datetime", title="Biomarkers (Various)", h_symmetry=False, v_symmetry=False, min_border=0, plot_height=height, y_range=[40, 140], plot_width=int(width/2 - 50), toolbar_location="above", outline_line_color="#666666", tools=plt_biomarkers_tools, active_scroll=wz) plot_blood.extra_y_ranges = {"ketones_range": Range1d(start=0, end=7)} plot_blood.add_layout(LinearAxis(y_range_name="ketones_range"), 'right') plot_blood.line('date', 'glucose', name="glucose", source=ma_cds_working, line_color="#FF7700", line_width=3, line_alpha=0.6, legend="Blood Glucose") plot_blood.cross('date', 'ketones', source=ma_cds_working, line_color="#C74D56", line_alpha=0.6, legend="Blood Ketones", y_range_name="ketones_range") plot_blood.ray(x=data['date'][1195],y=.5, length=0, angle=0, line_color="#C74D56", line_width=1, y_range_name="ketones_range") plot_blood.ray(x=data['date'][1195],y=1, length=0, angle=0, line_color="#C74D56", line_width=1, y_range_name="ketones_range") plot_blood.legend.location = "top_left" plot_blood.legend.click_policy="hide" #Plot Heartrate plot_rhr = figure(x_axis_type="datetime", title="Morning Resting HR", h_symmetry=False, v_symmetry=False, min_border=0, plot_height=int(height/2), plot_width=int(width/2), x_range=plot_blood.x_range, outline_line_color="#666666") plot_rhr.line('date', 'bpm', name="bpm", source=ma_cds_working, line_color="#8B0A50", line_width=3, line_alpha=0.6, legend="BPM") plot_rhr.line('date', 'hrv', name="hrv", source=ma_cds_working, line_color="#0a8b45", line_width=3, line_alpha=0.6, legend="HRV") plot_rhr.line('date', 'scaled_hrv', name="scaled_hrv", source=ma_cds_working, line_color="#333366", line_width=3, line_alpha=0.6, y_range_name="scaled_hrv_range", legend="HRV (Scaled)") #***TODO*** Add SNS/PNS indicator plot_rhr.extra_y_ranges = {"scaled_hrv_range": Range1d(start=1, end=10)} plot_rhr.add_layout(LinearAxis(y_range_name="scaled_hrv_range"), 'right') plot_rhr.legend.location = "bottom_left" plot_rhr.legend.click_policy="hide" plot_rhr.toolbar_location = None #Plot sleep quality (single indicator) plot_osq = figure(x_axis_type="datetime", title="Overall Sleep Quality", h_symmetry=False, v_symmetry=False, min_border=0, plot_height=int(height/2), plot_width=int(width/2), y_range=[1, 9], x_range=plot_blood.x_range, outline_line_color="#666666") plot_osq.line('date', 'sleep_overall_q', source=ma_cds_working, line_color="#333366", line_width=3, line_alpha=0.6) plot_osq.toolbar_location = None #Plot body compostion (weight and bodyfat) plot_composition = figure(x_axis_type="datetime", title="Body Composition", h_symmetry=False, v_symmetry=False, min_border=0, plot_height=height, plot_width=width, y_range=[120,180], toolbar_location="above", outline_line_color="#666666", tools=plt_bcomp_tools, active_scroll=wz2) plot_composition.extra_y_ranges = {"bodyfat_range": Range1d(start=5, end=15)} plot_composition.add_layout(LinearAxis(y_range_name="bodyfat_range"), 'right') plot_composition.line('date', 'weight', name="weight", source=ma_cds_working, line_color="#FF7700", line_width=3, line_alpha=0.6, legend="Weight") plot_composition.line('date', 'bodyfat', source=ma_cds_working, line_color="#333366", line_width=3, line_alpha=0.6, legend="Bodyfat", y_range_name="bodyfat_range") plot_composition.legend.location = "top_left" plot_composition.legend.click_policy="hide" #Plot sleep (all indicators) plot_sleep = figure(x_axis_type="datetime", title="Sleep", h_symmetry=False, v_symmetry=False, min_border=0, plot_height=height, plot_width=width, y_range=[1,9], x_range=plot_blood.x_range, toolbar_location="above", outline_line_color="#666666", tools=plt_sleep_tools, active_scroll=wz3) plot_sleep.extra_y_ranges = {"sleep_range": Range1d(start=0, end=12)} plot_sleep.add_layout(LinearAxis(y_range_name="sleep_range"), 'right') plot_sleep.line('date', 'sleep_overall_q', name='sleep_overall_q', source=ma_cds_working, line_color="#8B0A50", line_width=2, line_alpha=0.6, legend="Sleep Quality") plot_sleep.line('date', 'sleep_how_much_more', source=ma_cds_working, line_color="#FF7700", line_width=2, line_alpha=0.6, legend="Satisfaction") plot_sleep.line('date', 'sleep_how_deep', source=ma_cds_working, line_color="#C74D56", line_width=2, line_alpha=0.6, legend="Depth") plot_sleep.line('date', 'sleep_interruptions', source=ma_cds_working, line_color="#0a8b45", line_width=2, line_alpha=0.6, legend="Interruptions") plot_sleep.line('date', 'sleep_duration', source=ma_cds_working, line_color="#333366", line_width=5, line_alpha=0.6, legend="Duration (hrs)", y_range_name="sleep_range") plot_sleep.legend.location = "top_left" plot_sleep.legend.click_policy="hide" #Statistics divs for the control panel div_days = Div() div_avg_bg = Div() div_avg_rhr = Div() div_avg_slp_dur = Div() div_avg_slp_q = Div() div_days_bc = Div() div_avg_wt = Div() div_avg_bf = Div() #Callbacks ma_cb = CustomJS(args=dict(w=ma_cds_working, s=ma_cds_static), code=MA_SLIDER_CODE) plot_blood.x_range.callback = CustomJS(args=dict(d_d=div_days, d_a_bg=div_avg_bg, d_a_r=div_avg_rhr, d_a_s_d=div_avg_slp_dur, d_a_s_q=div_avg_slp_q, s=ma_cds_static), code=BODY_STATS_CODE) plot_composition.x_range.callback = CustomJS(args=dict(d_d_bc=div_days_bc, d_a_wt=div_avg_wt, d_a_bf=div_avg_bf, s=ma_cds_static), code=BODY_COMP_STATS_CODE) ma_slider = Slider(start=1, end=30, value=7, step=1, title="Moving Average", callback=ma_cb) return components((div_days, div_avg_bg, div_avg_rhr, div_avg_slp_dur, div_avg_slp_q, div_days_bc, div_avg_wt, div_avg_bf, plot_blood, plot_rhr, plot_osq, plot_composition, plot_sleep, ma_slider))
doc.clear() doc.title = 'Homework 4 Question 2' source = ColumnDataSource( data=dict(x=[], y=[], radius=[], top=[], bottom=[], left=[], right=[])) p = figure(plot_width=800, plot_height=800, x_range=(-20, 20), y_range=(-20, 20), tools=[ BoxSelectTool(), BoxZoomTool(), ResetTool(), WheelZoomTool(), SaveTool(), PanTool() ], x_axis_label='Units', y_axis_label="Units", toolbar_location="right") circ = p.circle(x='x', y='y', radius='radius', color="firebrick", alpha=0.8, source=source, radius_dimension='max') squa = p.quad(top='top', bottom='bottom',
def generate_plot(self): """Calculates mean and standard deviation for measure(s) by model, then generates a bar plot of model vs mean performance. TODO: Finish this doc. """ # Use this for a built-in bar plot instead, # but doesn't work with custom hover tool #p = Bar(self.data,label='modelname',values=self.measure,agg='mean',\ # title='Mean %s Performance By Model'%self.measure,legend=None,\ # tools=tools, color='modelname') #self.script,self.div = components(p) #return # TODO: hardcoded self.measure[0] for now, but should incorporate # a for loop somewhere to subplot for each selected measure # TODO: add significance information (see plot_bar_pretty # and randttest in narf_analysis) # build new pandas series of stdev values to be added to dataframe # if want to show more info on tooltip in the future, just need # to build an appropriate series to add and then build its tooltip #in the create_hover function modelnames = self.data.index.levels[0].tolist() stdev_col = pd.Series(index=modelnames) mean_col = pd.Series(index=modelnames) median_col = pd.Series(index=modelnames) n_cells_col = pd.Series(index=modelnames) #for each model, find the stdev and mean over the measure values, then #assign those values to new Series objects to use for the plot for model in modelnames: values = self.data[self.measure[0]].loc[model] stdev = values.std(skipna=True) mean = values.mean(skipna=True) median = values.median(skipna=True) if (math.isnan(stdev)) or (math.isnan(mean)) or (math.isnan(median)): # If either statistic comes out as NaN, entire column was NaN, # so model doesn't have the necessary data. continue stdev_col.at[model] = stdev mean_col.at[model] = mean median_col.at[model] = median n_cells_col.at[model] = values.count() newData = pd.DataFrame.from_dict({ 'stdev':stdev_col, 'mean':mean_col, 'median':median_col, 'n_cells':n_cells_col, }) # Drop any models with NaN values, since that means they had no # performance data for one or more columns. newData.dropna(axis=0, how='any', inplace=True) if newData.size == 0: self.script,self.div = ( "Error, no plot to display.", "None of the models contained valid performance data." ) return dat_source = ColumnDataSource(newData) tools = [ PanTool(), SaveTool(), WheelZoomTool(), ResetTool(), self.create_hover() ] xrange = FactorRange(factors=modelnames) yrange = Range1d( start=0, end=(max(newData['mean'])*1.5) ) p = figure( x_range=xrange, x_axis_label=( "Modelname, prefix: {0}, suffix: {1}" .format(self.pre, self.suf) ), y_range=yrange, y_axis_label='Mean %s'%self.measure[0], title="Mean %s Performance By Model"%self.measure[0], tools=tools, responsive=True, toolbar_location=TOOL_LOC, toolbar_sticky=TOOL_STICK, output_backend="svg" ) p.xaxis.major_label_orientation=-(np.pi/4) glyph = VBar( x='index', top='mean', bottom=0, width=VBAR_WIDTH, fill_color=VBAR_FILL, line_color='black' ) p.add_glyph(dat_source,glyph) # workaround to prevent title and toolbar from overlapping grid = gridplot( [p], ncols=GRID_COLS, responsive=True, ) self.script, self.div = components(grid)
def bubble_plot_tabs(dataframes): dataframes = dataframes.copy() # convert asset dicts to pandas dataframes base_df = pd.DataFrame.from_dict(dataframes['base_output_by_asset']) reform_df = pd.DataFrame.from_dict(dataframes['reform_output_by_asset']) change_df = pd.DataFrame.from_dict(dataframes['changed_output_by_asset']) list_df = [base_df, change_df, reform_df] list_string = ['base', 'change', 'reform'] data_sources = {} for i, df in enumerate(list_df): # remove data from Intellectual Property, Land, and Inventories Categories df = df[~df['asset_category']. isin(['Intellectual Property', 'Land', 'Inventories'])].copy() df = df.dropna() # define the size DataFrame, if change, use base sizes if list_string[i] == 'base': SIZES = list(range(20, 80, 15)) size = pd.qcut(df['assets_c'].values, len(SIZES), labels=SIZES) size_c = pd.qcut(df['assets_c'].values, len(SIZES), labels=SIZES) size_nc = pd.qcut(df['assets_nc'].values, len(SIZES), labels=SIZES) df['size'] = size df['size_c'] = size_c df['size_nc'] = size_nc else: df['size'] = size df['size_c'] = size_c df['size_nc'] = size_nc # form the two Categories: Equipment and Structures equipment_df = df[(~df.asset_category.str.contains('Structures')) & (~df.asset_category.str.contains('Buildings'))] structure_df = df[(df.asset_category.str.contains('Structures')) | (df.asset_category.str.contains('Buildings'))] format_fields = [ 'metr_c', 'metr_nc', 'metr_c_d', 'metr_nc_d', 'metr_c_e', 'metr_nc_e', 'mettr_c', 'mettr_nc', 'mettr_c_d', 'mettr_nc_d', 'mettr_c_e', 'mettr_nc_e', 'rho_c', 'rho_nc', 'rho_c_d', 'rho_nc_d', 'rho_c_e', 'rho_nc_e', 'z_c', 'z_nc', 'z_c_d', 'z_nc_d', 'z_c_e', 'z_nc_e' ] # Make short category make_short = { 'Instruments and Communications Equipment': 'Instruments and Communications', 'Office and Residential Equipment': 'Office and Residential', 'Other Equipment': 'Other', 'Transportation Equipment': 'Transportation', 'Other Industrial Equipment': 'Other Industrial', 'Nonresidential Buildings': 'Nonresidential Bldgs', 'Residential Buildings': 'Residential Bldgs', 'Mining and Drilling Structures': 'Mining and Drilling', 'Other Structures': 'Other', 'Computers and Software': 'Computers and Software', 'Industrial Machinery': 'Industrial Machinery' } equipment_df['short_category'] = equipment_df['asset_category'].map( make_short) structure_df['short_category'] = structure_df['asset_category'].map( make_short) # Add the Reform and the Baseline to Equipment Asset for f in format_fields: equipment_copy = equipment_df.copy() equipment_copy['rate'] = equipment_copy[f] equipment_copy['hover'] = equipment_copy.apply( lambda x: "{0:.1f}%".format(x[f] * 100), axis=1) simple_equipment_copy = equipment_copy.filter(items=[ 'size', 'size_c', 'size_nc', 'rate', 'hover', 'short_category', 'Asset' ]) data_sources[list_string[i] + '_equipment_' + f] = ColumnDataSource(simple_equipment_copy) # Add the Reform and the Baseline to Structures Asset for f in format_fields: structure_copy = structure_df.copy() structure_copy['rate'] = structure_copy[f] structure_copy['hover'] = structure_copy.apply( lambda x: "{0:.1f}%".format(x[f] * 100), axis=1) simple_structure_copy = structure_copy.filter(items=[ 'size', 'size_c', 'size_nc', 'rate', 'hover', 'short_category', 'Asset' ]) data_sources[list_string[i] + '_structure_' + f] = ColumnDataSource(simple_structure_copy) # Create initial data sources to plot on load if list_string[i] == 'base': equipment_copy = equipment_df.copy() equipment_copy['rate'] = equipment_copy['mettr_c'] equipment_copy['hover'] = equipment_copy.apply( lambda x: "{0:.1f}%".format(x['mettr_c'] * 100), axis=1) simple_equipment_copy = equipment_copy.filter(items=[ 'size', 'size_c', 'size_nc', 'rate', 'hover', 'short_category', 'Asset' ]) data_sources['equip_source'] = ColumnDataSource( simple_equipment_copy) structure_copy = structure_df.copy() structure_copy['rate'] = structure_copy['mettr_c'] structure_copy['hover'] = structure_copy.apply( lambda x: "{0:.1f}%".format(x['mettr_c'] * 100), axis=1) simple_structure_copy = structure_copy.filter(items=[ 'size', 'size_c', 'size_nc', 'rate', 'hover', 'short_category', 'Asset' ]) data_sources['struc_source'] = ColumnDataSource( simple_structure_copy) # Define categories for Equipments assets equipment_assets = [ 'Computers and Software', 'Instruments and Communications', 'Office and Residential', 'Transportation', 'Industrial Machinery', 'Other Industrial', 'Other' ] # Define categories for Structures assets structure_assets = [ 'Residential Bldgs', 'Nonresidential Bldgs', 'Mining and Drilling', 'Other' ] # Equipment plot p = figure( plot_height=540, plot_width=990, y_range=list(reversed(equipment_assets)), tools='hover', background_fill_alpha=0, title= 'Marginal Effective Total Tax Rates on Corporate Investments in Equipment' ) p.title.align = 'center' p.title.text_color = '#6B6B73' hover = p.select(dict(type=HoverTool)) hover.tooltips = [('Asset', ' @Asset (@hover)')] p.xaxis.axis_label = "Marginal effective total tax rate" p.xaxis[0].formatter = NumeralTickFormatter(format="0.1%") p.toolbar_location = None p.min_border_right = 5 p.outline_line_width = 5 p.border_fill_alpha = 0 p.xaxis.major_tick_line_color = "firebrick" p.xaxis.major_tick_line_width = 3 p.xaxis.minor_tick_line_color = "orange" p.outline_line_width = 1 p.outline_line_alpha = 1 p.outline_line_color = "black" p.circle(x='rate', y='short_category', color=BLUE, size='size', line_color="#333333", fill_alpha=.4, source=data_sources['equip_source'], alpha=.4) # Style the tools p.add_tools(WheelZoomTool(), ResetTool(), SaveTool()) p.toolbar_location = "right" p.toolbar.logo = None # Define and add a legend legend_cds = ColumnDataSource({ 'size': SIZES, 'label': ['<$20B', '', '', '<$1T'], 'x': [0, .15, .35, .6] }) p_legend = figure(height=150, width=480, x_range=(-0.075, .75), title='Asset Amount') p_legend.circle(y=None, x='x', size='size', source=legend_cds, color=BLUE, fill_alpha=.4, alpha=.4, line_color="#333333") l = LabelSet(y=None, x='x', text='label', x_offset=-20, y_offset=-50, source=legend_cds) p_legend.add_layout(l) p_legend.axis.visible = False p_legend.grid.grid_line_color = None p_legend.toolbar.active_drag = None data_sources['equip_plot'] = p # Structures plot p2 = figure( plot_height=540, plot_width=990, y_range=list(reversed(structure_assets)), tools='hover', background_fill_alpha=0, title= 'Marginal Effective Total Tax Rates on Corporate Investments in Structures' ) p2.title.align = 'center' p2.title.text_color = '#6B6B73' hover = p2.select(dict(type=HoverTool)) hover.tooltips = [('Asset', ' @Asset (@hover)')] p2.xaxis.axis_label = "Marginal effective total tax rate" p2.xaxis[0].formatter = NumeralTickFormatter(format="0.1%") p2.toolbar_location = None p2.min_border_right = 5 p2.outline_line_width = 0 p2.border_fill_alpha = 0 p2.xaxis.major_tick_line_color = "firebrick" p2.xaxis.major_tick_line_width = 3 p2.xaxis.minor_tick_line_color = "orange" p2.circle(x='rate', y='short_category', color=RED, size='size', line_color="#333333", fill_alpha=.4, source=data_sources['struc_source'], alpha=.4) p2.outline_line_width = 1 p2.outline_line_alpha = 1 p2.outline_line_color = "black" # Style the tools p2.add_tools(WheelZoomTool(), ResetTool(), SaveTool()) p2.toolbar_location = "right" p2.toolbar.logo = None # Define and add a legend p2_legend = figure(height=150, width=380, x_range=(-0.075, .75), title='Asset Amount') p2_legend.circle(y=None, x='x', size='size', source=legend_cds, color=RED, fill_alpha=.4, alpha=.4, line_color="#333333") l2 = LabelSet(y=None, x='x', text='label', x_offset=-20, y_offset=-50, source=legend_cds) p2_legend.add_layout(l2) p2_legend.axis.visible = False p2_legend.grid.grid_line_color = None p2_legend.toolbar.active_drag = None data_sources['struc_plot'] = p2 # add buttons controls_callback = CustomJS(args=data_sources, code=CONTROLS_CALLBACK_SCRIPT) c_nc_buttons = RadioButtonGroup(labels=['Corporate', 'Noncorporate'], active=0, callback=controls_callback) controls_callback.args['c_nc_buttons'] = c_nc_buttons format_buttons = RadioButtonGroup(labels=['Baseline', 'Reform', 'Change'], active=0, callback=controls_callback) controls_callback.args['format_buttons'] = format_buttons interest_buttons = RadioButtonGroup( labels=['METTR', 'METR', 'Cost of Capital', 'Depreciation'], active=0, width=700, callback=controls_callback) controls_callback.args['interest_buttons'] = interest_buttons type_buttons = RadioButtonGroup( labels=['Typically Financed', 'Equity Financed', 'Debt Financed'], active=0, width=700, callback=controls_callback) controls_callback.args['type_buttons'] = type_buttons # Create Tabs tab = Panel(child=column([p, p_legend]), title='Equipment') tab2 = Panel(child=column([p2, p2_legend]), title='Structures') tabs = Tabs(tabs=[tab, tab2]) layout = gridplot(children=[[tabs], [c_nc_buttons, interest_buttons], [format_buttons, type_buttons]]) # Create components js, div = components(layout) cdn_js = CDN.js_files[0] cdn_css = CDN.css_files[0] return js, div, cdn_js, cdn_css
def plot(self, source1, source2, source3, source4, source5, source6, source7, source8, source9): a = self.a b = self.b hover = HoverTool(tooltips=[ ("PCA1", "($x)"), ("PCA2", "($y)"), ("NAME", "(@N)"), ]) p = figure(title="CHEMICAL SPACE BY MORGAN2 FP", x_axis_label="PC 1 " + "(" + str(a) + "%)", y_axis_label="PC 2 " + "(" + str(b) + "%)", x_range=(-7, 7), y_range=(-7, 7), tools=[hover], plot_width=1000, plot_height=800) FDA_plot = p.circle(x="x", y="y", source=source1, color="darkslateblue", size=5) PPI_plot = p.circle(x="x", y="y", source=source2, color="yellowgreen", size=5) MACRO_plot = p.circle(x="x", y="y", source=source3, color="lightsteelblue", size=5) NP_plot = p.circle(x="x", y="y", source=source4, color="olive", size=5) PEP_FDA_plot = p.circle(x="x", y="y", source=source5, color="darkslategray", size=5) LIN_plot = p.circle(x="x", y="y", source=source6, color="aquamarine", size=5) LIN_NM_plot = p.circle(x="x", y="y", source=source7, color="teal", size=5) CYC_plot = p.circle(x="x", y="y", source=source8, color="lightpink", size=5) CYC_NM_plot = p.circle(x="x", y="y", source=source9, color="mediumvioletred", size=5) p.add_tools(LassoSelectTool(), ZoomInTool(), ZoomOutTool(), SaveTool(), PanTool()) legend = Legend(items=[ ("FDA", [FDA_plot]), ("PPI", [PPI_plot]), ("MACRO", [MACRO_plot]), ("NP", [NP_plot]), ("PEP FDA", [PEP_FDA_plot]), ("LIN", [LIN_plot]), ("LIN NM", [LIN_NM_plot]), ("CYC", [CYC_plot]), ("CYC NM", [CYC_NM_plot]), ], location="center", orientation="vertical", click_policy="hide") p.add_layout(legend, place='right') p.xaxis.axis_label_text_font_size = "20pt" p.yaxis.axis_label_text_font_size = "20pt" p.xaxis.axis_label_text_color = "black" p.yaxis.axis_label_text_color = "black" p.xaxis.major_label_text_font_size = "18pt" p.yaxis.major_label_text_font_size = "18pt" p.title.text_font_size = "22pt" return p
def add_graph(self, field_names, legends, window='hann', window_length=256, noverlap=128): """ add a spectrogram plot to the graph field_names: can be a list of fields from the data set, or a list of functions with the data set as argument and returning a tuple of (field_name, data) legends: description for the field_names that will appear in the title of the plot window: the type of window to use for the frequency analysis. check scipy documentation for available window types. window_length: length of the analysis window in samples. noverlap: number of overlapping samples between windows. """ if self._had_error: return try: data_set = {} data_set['timestamp'] = self._cur_dataset.data['timestamp'] # calculate the sampling frequency # (Note: logging dropouts are not taken into account here) delta_t = ((data_set['timestamp'][-1] - data_set['timestamp'][0]) * 1.0e-6) / len(data_set['timestamp']) sampling_frequency = int(1.0 / delta_t) if sampling_frequency < 100: # require min sampling freq self._had_error = True return field_names_expanded = self._expand_field_names( field_names, data_set) # calculate the spectrogram psd = dict() for key in field_names_expanded: frequency, time, psd[key] = scipy.signal.spectrogram( data_set[key], fs=sampling_frequency, window=window, nperseg=window_length, noverlap=noverlap, scaling='density') # sum all psd's key_it = iter(psd) sum_psd = psd[next(key_it)] for key in key_it: sum_psd += psd[key] # offset = int(((1024/2.0)/250.0)*1e6) # scale time to microseconds and add start time as offset time = time * 1.0e6 + self._cur_dataset.data['timestamp'][0] color_mapper = LinearColorMapper(palette=viridis(256), low=-80, high=0) image = [10 * np.log10(sum_psd)] title = self.title for legend in legends: title += " " + legend title += " [dB]" # assume maximal data points per pixel at full resolution max_num_data_points = 2.0 * self._config['plot_width'] if len(time) > max_num_data_points: step_size = int(len(time) / max_num_data_points) time = time[::step_size] image[0] = image[0][:, ::step_size] self._p.y_range = Range1d(frequency[0], frequency[-1]) self._p.toolbar_location = 'above' self._p.image(image=image, x=time[0], y=frequency[0], dw=(time[-1] - time[0]), dh=(frequency[-1] - frequency[0]), color_mapper=color_mapper) color_bar = ColorBar(color_mapper=color_mapper, major_label_text_font_size="5pt", ticker=BasicTicker(desired_num_ticks=5), formatter=PrintfTickFormatter(format="%f"), title='[dB]', label_standoff=6, border_line_color=None, location=(0, 0)) self._p.add_layout(color_bar, 'right') # add plot zoom tool that only zooms in time axis wheel_zoom = WheelZoomTool() self._p.toolbar.tools = [ PanTool(), wheel_zoom, BoxZoomTool(dimensions="width"), ResetTool(), SaveTool() ] # updated_tools self._p.toolbar.active_scroll = wheel_zoom except (KeyError, IndexError, ValueError, ZeroDivisionError) as error: print(type(error), "(" + self._data_name + "):", error) self._had_error = True
<div> <img src="@imgs" height="@imgs_ht" alt="@imgs" width="@imgs_wd" style="float: left; margin: 0px 15px 15px 0px;" border="1" ></img> </div> <div> <img src="@flag" height="@flag_ht" alt="@imgs" width="@flag_wd" ></img> <span style="font-size: 14px; font-weight: bold;">@name</span> </div> <div> <span style="font-size: 10px: bold;">@addr</span> </div> </div> """) wheel_zoom = WheelZoomTool() tap = TapTool() tap.renderers = [] tap.callback = OpenURL(url='@embassy_url') plot.add_tools(PanTool(), wheel_zoom, hover, tap, ResetTool(), SaveTool()) plot.toolbar.active_scroll = wheel_zoom ### Export show(plot)
def modify_doc(doc): print("Someone is viewing the Graph") with open(sys.argv[3] + 'lossdump.csv', 'r') as f: reader = csv.reader(f) array = np.array(list(reader)) iterationarray = (array[:, 0]).tolist() lossarray = (array[:, 1]).tolist() learningratearray = (array[:, 2]).tolist() imgprocessarray = (array[:, 3]).tolist() for i in range(0, len(iterationarray)): iterationarray[i] = int(float(iterationarray[i].split(':')[1])) lossarray[i] = float(lossarray[i].split(':')[1]) learningratearray[i] = float(learningratearray[i].split(':')[1]) imgprocessarray[i] = int(imgprocessarray[i].split(':')[1]) hover = HoverTool(tooltips=[ ("index", "$index"), ("(x,y)", "(@x,@y)"), ]) # tck = interpolate.UnivariateSpline(imgprocessarray, lossarray) # xnew = np.linspace(min(lossarray), max(lossarray), num=len(lossarray), endpoint=True) # check = tck(xnew) # print(type(check)) # print(check.shape) fig1 = figure(title='Training Loss Plot', width=1500, height=400, x_axis_label='Images Processed', y_axis_label='Training Loss', tools=[BoxZoomTool(), ResetTool(), hover, SaveTool()]) fig1.line(x=imgprocessarray, y=lossarray, line_width=1) # fig1.line(x=imgprocessarray, y=check.tolist(),line_width=1,line_color="#f46d43" ) fig1.xaxis[0].formatter.use_scientific = False doc.add_root(fig1) fig2 = figure(title='Learning Rate Plot', width=1500, height=400, x_axis_label='Images Processed', y_axis_label='Learning Rate Loss', tools=[BoxZoomTool(), ResetTool(), hover, SaveTool()]) fig2.line(x=imgprocessarray, y=learningratearray, line_width=1) fig2.xaxis[0].formatter.use_scientific = False doc.add_root(fig2) cfg_file = sys.argv[2] with open(sys.argv[2]) as file: losslines = file.read().splitlines() subdivision = 0 if ("[yolo]") in losslines: num_of_yolo_layers = losslines.count("[yolo]") else: print("Change the Detection Layer from YOLO to REGION/DETECTION") print("Classification Models Visualization not supported now") exit(1) list2d = [] AvgIOU, Class, Obj, NoObj, FIFTYR, SEVENFIVER = [[], []], [[], []], [ [], [] ], [[], []], [[], []], [[], []] count = 0 linenumber = 0 tempavgiou, tempclass, tempobj, tempnoobj, temp50R, temp75R = 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 for index in range(0, len(losslines)): if losslines[index].find( "subdivision") != -1 and losslines[index].find("#") == -1: subdivision = losslines[index] subdivision = int(re.findall(r'\b\d+\b', subdivision)[0]) if subdivision == 0: print("Check the subdivisions of your CFG File") exit(1) with open(sys.argv[3] + "detectiondump.csv") as f: lines = f.readlines() linenumber = 0 batchcount = 0 counter = 0 tempavgiou,tempclass,tempobj,tempnoobj,temp50R,temp75R = [],[],[],[],[],[] AvgIOU, Class, Obj, NoObj, FIFTYR, SEVENFIVER = [], [], [], [], [], [] num_lines = len(lines) for index in range(0, num_of_yolo_layers): tempavgiou.append([0.0]) tempclass.append([0.0]) tempobj.append([0.0]) tempnoobj.append([0.0]) temp50R.append([0.0]) temp75R.append([0.0]) AvgIOU.append([]) Class.append([]) Obj.append([]) NoObj.append([]) FIFTYR.append([]) SEVENFIVER.append([]) while linenumber < num_lines - 1: for index in range(0, num_of_yolo_layers): currentline = lines[linenumber].strip() if currentline.find("Images_Processed") != -1: for index_inner in range(0, num_of_yolo_layers): AvgIOU[index_inner].append(tempavgiou[index_inner][0] * 2 / batchcount) Class[index_inner].append(tempclass[index_inner][0] * 2 / batchcount) Obj[index_inner].append(tempobj[index_inner][0] * 2 / batchcount) NoObj[index_inner].append(tempnoobj[index_inner][0] * 2 / batchcount) FIFTYR[index_inner].append(temp50R[index_inner][0] * 2 / batchcount) SEVENFIVER[index_inner].append(temp75R[index_inner][0] * 2 / batchcount) linenumber += 1 batchcount = 0 tempavgiou,tempclass,tempobj,tempnoobj,temp50R,temp75R = [],[],[],[],[],[] for index in range(0, num_of_yolo_layers): tempavgiou.append([0.0]) tempclass.append([0.0]) tempobj.append([0.0]) tempnoobj.append([0.0]) temp50R.append([0.0]) temp75R.append([0.0]) else: if currentline.split(',')[1].split(':')[1] != "-nan": tempavgiou[index][0] = tempavgiou[index][0] + float( currentline.split(',')[1].split(':')[1]) tempclass[index][0] = tempclass[index][0] + float( currentline.split(',')[2].split(':')[1]) tempobj[index][0] = tempobj[index][0] + float( currentline.split(',')[3].split(':')[1]) tempnoobj[index][0] = tempnoobj[index][0] + float( currentline.split(',')[4].split(':')[1]) temp50R[index][0] = temp50R[index][0] + float( currentline.split(',')[5].split(':')[1]) temp75R[index][0] = temp75R[index][0] + float( currentline.split(',')[6].split(':')[1]) linenumber += 1 batchcount += 1 for index in range(0, num_of_yolo_layers): fig3 = figure(title='IOU Yolo Layer ' + str(index + 1), width=1500, height=400, x_axis_label='Images Processed', y_axis_label='IOU of Yolo Layer ' + str(index + 1), tools=[BoxZoomTool(), ResetTool(), hover, SaveTool()]) fig3.line(x=imgprocessarray, y=AvgIOU[index], line_width=1) fig3.xaxis[0].formatter.use_scientific = False doc.add_root(fig3) for index in range(0, num_of_yolo_layers): fig4 = figure(title='Class Yolo Layer ' + str(index + 1), width=1500, height=400, x_axis_label='Images Processed', y_axis_label='Class of Yolo Layer' + str(index + 1), tools=[BoxZoomTool(), ResetTool(), hover, SaveTool()]) fig4.line(x=imgprocessarray, y=Class[index], line_width=1) fig4.xaxis[0].formatter.use_scientific = False doc.add_root(fig4) for index in range(0, num_of_yolo_layers): fig5 = figure(title='Objectness Yolo Layer ' + str(index + 1), width=1500, height=400, x_axis_label='Images Processed', y_axis_label='Objectness of Yolo Layer' + str(index + 1), tools=[BoxZoomTool(), ResetTool(), hover, SaveTool()]) fig5.line(x=imgprocessarray, y=Obj[index], line_width=1) fig5.xaxis[0].formatter.use_scientific = False doc.add_root(fig5) for index in range(0, num_of_yolo_layers): fig6 = figure(title='No Objectness Yolo Layer ' + str(index + 1), width=1500, height=400, x_axis_label='Images Processed', y_axis_label='No Objectness of Yolo Layer' + str(index + 1), tools=[BoxZoomTool(), ResetTool(), hover, SaveTool()]) fig6.line(x=imgprocessarray, y=NoObj[index], line_width=1) fig6.xaxis[0].formatter.use_scientific = False doc.add_root(fig6) for index in range(0, num_of_yolo_layers): fig7 = figure(title='.5 IOU Recall Yolo Layer ' + str(index + 1), width=1500, height=400, x_axis_label='Images Processed', y_axis_label='.5 IOU Recall of Yolo Layer' + str(index + 1), tools=[BoxZoomTool(), ResetTool(), hover, SaveTool()]) fig7.line(x=imgprocessarray, y=FIFTYR[index], line_width=1) fig7.xaxis[0].formatter.use_scientific = False doc.add_root(fig7) for index in range(0, num_of_yolo_layers): fig8 = figure(title='.75 IOU Recall Yolo Layer ' + str(index + 1), width=1500, height=400, x_axis_label='Images Processed', y_axis_label='.75 IOU Recall of Yolo Layer' + str(index + 1), tools=[BoxZoomTool(), ResetTool(), hover, SaveTool()]) fig8.line(x=imgprocessarray, y=SEVENFIVER[index], line_width=1) fig8.xaxis[0].formatter.use_scientific = False doc.add_root(fig8) doc.title = "Darknet Visualization!"
def large_plot(n): from bokeh.models import (Plot, LinearAxis, Grid, GlyphRenderer, ColumnDataSource, DataRange1d, PanTool, ZoomInTool, ZoomOutTool, WheelZoomTool, BoxZoomTool, BoxSelectTool, SaveTool, ResetTool) from bokeh.models.layouts import Column from bokeh.models.glyphs import Line col = Column() objects = set([col]) for i in xrange(n): source = ColumnDataSource(data=dict(x=[0, i + 1], y=[0, i + 1])) xdr = DataRange1d() ydr = DataRange1d() plot = Plot(x_range=xdr, y_range=ydr) xaxis = LinearAxis(plot=plot) yaxis = LinearAxis(plot=plot) xgrid = Grid(plot=plot, dimension=0) ygrid = Grid(plot=plot, dimension=1) tickers = [ xaxis.ticker, xaxis.formatter, yaxis.ticker, yaxis.formatter ] glyph = Line(x='x', y='y') renderer = GlyphRenderer(data_source=source, glyph=glyph) plot.renderers.append(renderer) pan = PanTool() zoom_in = ZoomInTool() zoom_out = ZoomOutTool() wheel_zoom = WheelZoomTool() box_zoom = BoxZoomTool() box_select = BoxSelectTool() save = SaveTool() reset = ResetTool() tools = [ pan, zoom_in, zoom_out, wheel_zoom, box_zoom, box_select, save, reset ] plot.add_tools(*tools) col.children.append(plot) objects |= set([ xdr, ydr, xaxis, yaxis, xgrid, ygrid, renderer, renderer.view, glyph, source, source.selected, source.selection_policy, plot, plot.x_scale, plot.y_scale, plot.toolbar, plot.title, box_zoom.overlay, box_select.overlay, ] + tickers + tools) return col, objects
# Hover hover = HoverTool(tooltips=[ ("||", "@orient"), ("Fe", "Fo# @fonum{0.0} @buffer"), ("Heat", "@hours hrs at @celsius C "), ("log10D", "@logD{0.0} in m2/s"), ("Type", "@exper, @mech"), ("Source", "@author @year @name"), ]) # The figure left, right, bottom, top = 6, 10, -16, -8 p = figure(plot_width=500, plot_height=500, tools=[BoxZoomTool(), hover, SaveTool(), ResetTool()], title="H diffusion in olivine", x_range=Range1d(left, right), y_range=Range1d(bottom, top)) p.circle('x', 'y', size=10, source=source, color='color', alpha='alpha') p.xaxis.axis_label = "1e4 / Temperature (K)" p.yaxis.axis_label = "log10 Diffusivity (m2/s)" # background area fills wD = 1.8 leftD = -10.4 rightD = -12.8 pvd = wD p.patch([6, 6, 10, 10], [leftD, leftD + wD, rightD + wD, rightD], alpha=0.075, line_width=0,