def _internal_bokeh(doc, example=None): from bokeh.layouts import row import asyncio async def clock_retrieve(period_secs: float, ttyout=False) -> None: import asyncio while True: await asyncio.sleep(period_secs) clock(period_secs=None, ttyout=ttyout) # calling itself synchronously # tick always in background but we retrieve its measurement every second. asyncio.get_running_loop().create_task(clock_retrieve(period_secs=1, ttyout=True)) # TODO : turn off retrieval when document is detached ? clocksourceview = inspect.getsource(Clock) thissourceview = inspect.getsource(_internal_bokeh) doc.add_root( grid( [ [PreText(text=clocksourceview), PreText(text=thissourceview)], # to help compare / visually debug [clock[["minute", "second"]].plot, clock[["minute", "second"]].table], # Note : even if we create multiple clock instances here, # the model is the same, and propagation will update all datasources... ] ) )
def Classification_metrics(clf, X_train, y_train, X_test, y_test, exec_time, algo_name=PreText(text="")): y_pred = clf.predict(X_test) rep = (classification_report(y_test, y_pred, output_dict=True)) dfrep1 = pd.DataFrame(rep).transpose() dfrep1['index'] = dfrep1.index source = ColumnDataSource(dfrep1) columns = [ TableColumn(field='index'), TableColumn(field='precision'), TableColumn(field='recall'), TableColumn(field='f1-score'), TableColumn(field='support') ] tet = DataTable(source=source, columns=columns, index_position=None) conf = "Confusion matrix : \n" + str( np.array(confusion_matrix(y_test, y_pred))) + " \n Classification report : " conf2 = PreText(text=conf, width=550) model_info = PreText(text=" Paramètres : " + str(clf.best_params_) + "\n Temps d'execution de : {} sec".format(exec_time)) learn = learning_graph(clf.best_estimator_, X_train, y_train) return column(pre5, algo_name, learn, model_info, conf2, tet)
def livebokeh(doc): doc.add_root( layout([ [PreText(text=inspect.getsource(LiveRandomWalk)), ld.plot], # to help compare / visually debug [ [ PreText(text=inspect.getsource(simulate)), PreText(text=inspect.getsource(livebokeh)), ], ld.table, ], ]))
def fridge(X,Y): start_time = time.time() name1 = PreText(text=" Ridge selected") target= select_cible.value X_train, X_test, y_train, y_test = train_test_split(X, Y, train_size=0.8) #define the model and parameters ridge = Ridge(normalize=True) params = {'alpha':[.01,.1,1.,10,100]} #Fit the model regR = GridSearchCV(ridge, param_grid=params, cv=5, n_jobs=6) regR.fit(X_train, y_train) #On applique sur les données d'apprentissage #predictions on train data y_train_predict=regR.predict(X_train) #predictions on test data y_pred = regR.predict(X_test) # Évaluation de l'algorithme print(regR.best_params_)#Meilleur paramètrage #Graphique p1 = figure( title="Prediction de la variable : %s " % target) p1.circle(range(len(y_pred)), y_pred[np.argsort(y_test)] , fill_alpha=0.8 , color = 'red', legend_label = "Prédiction")#,source=source) p1.line(range(len(y_test)), np.sort(y_test) , color = 'blue', legend_label = "Echantillon test") #données réelles p1.plot_width = 900 exec_time = round((time.time() - start_time),2) resu1 = row(p1, Regression_metrics(regR, X_train,y_train,X_test,y_test, exec_time, name1)) #column(blabla5,model_info,pre5,learn)) return resu1
def create_info(displaySet, displayParam, ogCity): """ Affiche un panneau textuel contenant des infomations sur le jeu de données affiché et la commune sélectionnée. Entrées : - displaySet : dataFrame contenant les données affichées - displayParam : paramètres que l'on souhaite aficher - ogCity : extract de la commune sélectionnée Sorties : - figure contenant le texte à afficher. """ stats = displaySet[displayParam].dropna().describe( percentiles=[0.5]).round(decimals=2) stats = stats[stats.index != 'count'] #On supprime la variable "count" deja affichée # Modification de l'intitulé des colonnes stats.columns = ["Taux " + str(elt) for elt in data_yr] # Creation du texte infoText = [ f"<b>Communes affichées</b> : {len(displaySet)}", f"<b>Commune sélectionnée</b> : {ogCity['nom']} ({ogCity['Code_DEP']})", "</br><b>Statistiques</b> : " + select_imp.value ] return [Div(text="</br>".join(infoText)), PreText(text=str(stats))]
def render_item(item: Tuple[str, str]): name, path = item path = Path(path) if path.is_file(): content = load_process_output(path) content = PreText(text=content) return Panel(child=content, title=name)
def create_dl1_widgets(self): self.w_dl1_dict = dict( cleaner=Select(title="Cleaner:", value='', width=5, options=WaveformCleanerFactory.subclass_names), extractor=Select(title="Extractor:", value='', width=5, options=ChargeExtractorFactory.subclass_names), extractor_t0=TextInput(title="T0:", value=''), extractor_window_width=TextInput(title="Window Width:", value=''), extractor_window_shift=TextInput(title="Window Shift:", value=''), extractor_sig_amp_cut_HG=TextInput(title="Significant Amplitude " "Cut (HG):", value=''), extractor_sig_amp_cut_LG=TextInput(title="Significant Amplitude " "Cut (LG):", value=''), extractor_lwt=TextInput(title="Local Pixel Weight:", value='')) for key, val in self.w_dl1_dict.items(): val.on_change('value', self.on_dl1_widget_change) self.wb_extractor = widgetbox( PreText(text="Charge Extractor Configuration"), self.w_dl1_dict['cleaner'], self.w_dl1_dict['extractor'], self.w_dl1_dict['extractor_t0'], self.w_dl1_dict['extractor_window_width'], self.w_dl1_dict['extractor_window_shift'], self.w_dl1_dict['extractor_sig_amp_cut_HG'], self.w_dl1_dict['extractor_sig_amp_cut_LG'], self.w_dl1_dict['extractor_lwt'])
def handle(doc): """ Note that the handle must create a brand new bokeh model every time it is called. Reference: https://github.com/bokeh/bokeh/issues/8579 """ spinner = PreText(text="loading...") layout = column(spinner) def progress(): spinner.text += "." def load(): try: bokeh_model = func(*args, **kwargs) # remove spinner and its update try: doc.remove_periodic_callback(progress) except Exception as e: warnings.warn( f"@servable: trying to remove periodic callback, got {type(e)}: {e}" ) layout.children.append(bokeh_model) layout.children.pop(0) except Exception as e: # exception handling message = PreText( text=f"{type(e)}: {e}\n{format_exc()}") layout.children.append(message) doc.add_root(layout) doc.add_periodic_callback(progress, 5000) doc.add_timeout_callback(load, 500) doc.title = title or func.__name__
def create_dl1_widgets(self): self.w_dl1_dict = dict( extractor=Select( title="Extractor:", value="", width=5, options=BokehFileViewer.extractor_product.values, ), extractor_window_start=TextInput(title="Window Start:", value=""), extractor_window_width=TextInput(title="Window Width:", value=""), extractor_window_shift=TextInput(title="Window Shift:", value=""), extractor_lwt=TextInput(title="Local Pixel Weight:", value=""), ) for val in self.w_dl1_dict.values(): val.on_change("value", self.on_dl1_widget_change) self.wb_extractor = widgetbox( PreText(text="Charge Extractor Configuration"), self.w_dl1_dict["extractor"], self.w_dl1_dict["extractor_window_start"], self.w_dl1_dict["extractor_window_width"], self.w_dl1_dict["extractor_window_shift"], self.w_dl1_dict["extractor_lwt"], )
def document(doc): sliders = [] pre = PreText(text='something') select = MultiSelect(title='Select the columns', options=list(df.columns)) button = Button(label='Update') for col in cols: MIN, MAX = df[col].min(), df[col].max() STEP = (MAX - MIN) / 100 slider = RangeSlider(start=MIN, end=MAX, step=STEP, value=(MIN, MAX), title=col) sliders.append(slider) def update(): values = [] txt = '({col} > {low}) & ({col} < {high})' for slider in sliders: low, high = slider.value low, high = float(low), float(high) formula = txt.format(col=slider.title, low=low, high=high) values.append(formula) q = '&'.join(values) summary_cols = select.value text = df.query(q)[summary_cols].describe() pre.text = str(text) button.on_click(update) l = layout([column(sliders), [select, button]], pre) doc.add_root(l)
def flasso(X,Y): start_time = time.time() name2 = PreText(text=" Lasso selected") target= select_cible.value X_train, X_test, y_train, y_test = train_test_split(X, Y, train_size=0.8) #define the model and parameters lasso = Lasso(normalize=True) params = {'alpha':[1,.5,.1,.01]} #Fit the model regL = GridSearchCV(lasso, param_grid=params, cv=5, n_jobs=6) regL.fit(X_train, y_train) #On applique sur les données d'apprentissage #predictions on train data y_train_predict=regL.predict(X_train) #predictions on test data y_pred = regL.predict(X_test) # Évaluation de l'algorithme print(regL.best_params_)#Meilleur paramètrage #Graphique p2 = figure( title="Prediction de la variable : %s " % target) p2.circle(range(len(y_pred)), y_pred[np.argsort(y_test)] , fill_alpha=0.8 , color = 'red', legend_label = "Prédiction")#,source=source) p2.line(range(len(y_test)), np.sort(y_test) , color = 'blue', legend_label = "Echantillon test") #données réelles p2.plot_width = 900 exec_time = round((time.time() - start_time),2) resu2 = row(p2, Regression_metrics(regL, X_train,y_train,X_test,y_test, exec_time, name2)) return resu2
def create_dl1_widgets(self): self.w_dl1_dict = dict( cleaner=Select(title="Cleaner:", value='', width=5, options=BokehFileViewer.cleaner_product.values), extractor=Select(title="Extractor:", value='', width=5, options=BokehFileViewer.extractor_product.values), extractor_t0=TextInput(title="T0:", value=''), extractor_window_width=TextInput(title="Window Width:", value=''), extractor_window_shift=TextInput(title="Window Shift:", value=''), extractor_lwt=TextInput(title="Local Pixel Weight:", value='')) for val in self.w_dl1_dict.values(): val.on_change('value', self.on_dl1_widget_change) self.wb_extractor = widgetbox( PreText(text="Charge Extractor Configuration"), self.w_dl1_dict['cleaner'], self.w_dl1_dict['extractor'], self.w_dl1_dict['extractor_t0'], self.w_dl1_dict['extractor_window_width'], self.w_dl1_dict['extractor_window_shift'], self.w_dl1_dict['extractor_lwt'])
def document(doc): condition = TextInput(title='Enter your condition') col = MultiSelect(title='Select the columns', options=list(df.columns)) button = Button(label='Update') pre = PreText() pre.text = condition.value def update(): cond = condition.value cols = col.value text = df.query(cond)[cols].describe() pre.text = str(text) button.on_click(update) l = layout([[[condition, button], col], pre]) doc.add_root(l)
def errorMessage(errText): pre = PreText(text="""Your text is initialized with the 'text' argument. The remaining Paragraph arguments are 'width' and 'height'. For this example, those values are 500 and 100 respectively.""", width=500, height=100) pre = Paragraph(text=errText, width=500, height=100) return pre
def test_set_style(self, bokeh_model_page: BokehModelPage) -> None: para = PreText(text=text, style={'font-size': '26px'}) page = bokeh_model_page(para) el = find_element_for(page.driver, para) assert 'font-size: 26px;' in el.get_attribute('style') assert page.has_no_console_errors()
def make_about_tab(): pkg = pkg_resources.require('iplot')[0] text = "\n".join(pkg.get_metadata_lines('METADATA')) text += "\n\n" text += "sys.version:" + sys.version pretext = PreText(text=text, width=600, height=600) panel = Panel(child=widgetbox(pretext), title="About") return panel
def test_displays_div_as_text(self, bokeh_model_page: BokehModelPage) -> None: para = PreText(text=text) page = bokeh_model_page(para) el = find_element_for(page.driver, para, "div pre") assert el.get_attribute("innerHTML") == escape(text, quote=None) assert page.has_no_console_errors()
def Regression_metrics(clf, X_train, y_train, X_test, y_test, exec_time, algo_name=PreText(text="")): y_train_predict = clf.predict(X_train) y_pred = clf.predict(X_test) model_info = PreText( text=" Paramètres : " + str(clf.best_params_) + " \n Le score R2 sur la base d'apprentissage est : {}".format( r2_score(y_train, y_train_predict)) + " \n Le score R2 sur la base du test est : {}".format( r2_score(y_test, y_pred)) + " \n Temps d'execution de : {} sec".format(exec_time)) learn = learning_graph(clf.best_estimator_, X_train, y_train) return column(pre5, algo_name, learn, model_info)
def test_displays_div_as_text(self, bokeh_model_page) -> None: para = PreText(text=text, css_classes=["foo"]) page = bokeh_model_page(para) el = page.driver.find_element_by_css_selector('.foo div pre') assert el.get_attribute("innerHTML") == escape(text, quote=None) assert page.has_no_console_errors()
def test_set_style(self, bokeh_model_page) -> None: para = PreText(text=text, css_classes=["foo"], style={'font-size': '26px'}) page = bokeh_model_page(para) el = page.driver.find_element_by_css_selector('.foo div') assert 'font-size: 26px;' in el.get_attribute('style') assert page.has_no_console_errors()
def _internal_bokeh(doc, example=None): import inspect moduleview = inspect.getsource(sys.modules[__name__]) doc.add_root( layout([ PreText(text=moduleview), ]) # TODO : niceties like pygments ?? )
def fsgd(X,Y): start_time = time.time() blabla5 = PreText(text=" SGD selected") scaler = StandardScaler(with_mean=False, copy=True) Feature_norm = scaler.fit_transform(X) #in case different scaled data type_feature = np.dtype(Y).name if ('int' in type_feature) or ('float' in type_feature): #Regression X_train, X_test, y_train, y_test = train_test_split(Feature_norm, Y, train_size=0.8) #or Feature_norm instead of X Regressor = SGDRegressor(max_iter=10**7//len(X_train)+1) #Model instance, empirically result for max_iter with 10**6 params2 = {'alpha':[ 1e-3, 1e-4, 1e-5, 1e-6 ], 'penalty':['l1', 'l2'], 'loss':['squared_loss','huber','epsilon_insensitive']} #Paramètres à tester clf = GridSearchCV(Regressor, param_grid=params2, cv=5, n_jobs=6) #,scoring=scorer) clf.fit(X_train, y_train) #On applique sur les données d'apprentissage #predictions on train data y_train_predict=clf.predict(X_train) #predictions on test data y_pred = clf.predict(X_test) print(clf.best_params_)#Meilleur paramètrage end_time = time.time() exec_time = round(end_time - start_time, 2) p5 = figure(title="Prediction de la variable : %s " % select_cible.value) p5.circle(range(len(y_pred)), y_pred[np.argsort(y_test)] , fill_alpha=0.8 , color = 'red', legend_label = "Prédiction")#,source=source) p5.line(range(len(y_test)), np.sort(y_test) , color = 'blue', legend_label = "Echantillon test") #données réelles p5.plot_width = 900 resu5 = row(p5, Regression_metrics(clf, X_train,y_train,X_test,y_test, exec_time, blabla5)) #column(blabla5,model_info,pre5,learn)) return resu5 else : #Classification X_train, X_test, y_train, y_test = train_test_split(Feature_norm, Y, train_size=0.8, stratify = Y) #stratify to avoid missing classes Classifier = SGDClassifier(max_iter=10**7//len(X_train)+1) #Model instance, empirically result for max_iter with 10**6 params = {'alpha':[ 1e-3, 1e-4, 1e-5, 1e-6 ], 'penalty':['l1', 'l2'], 'loss':['hinge','log']} #Paramètres à tester clf = GridSearchCV(Classifier, param_grid=params, cv=5, n_jobs=6)#scoring=scorer) clf.fit(X_train, y_train) #On applique sur les données d'apprentissage #predictions on train data y_train_predict=clf.predict(X_train) #predictions on test data y_pred=clf.predict(X_test) # Évaluation de l'algorithme print(clf.best_params_) end_time = time.time() exec_time = round(end_time - start_time, 2) #Graphique categ = y_test.astype("category") dico_tmp = dict(enumerate(categ.cat.categories)) dico = dict((v, k) for k, v in dico_tmp.items()) #on converti les categories en entier y_test_int = y_test.map(dico) y_pred_int = pd.Series(y_pred).map(dico) dico_bokeh = Paragraph(text=" Dictionnaire des correspondances (clef, valeur) : \n "+str(dico), width= 1000) #Graphiique p5 = figure( title="Prediction de la variable : %s " % select_cible.value, x_axis_label = "x" , y_axis_label = "y") p5.circle(range(len(y_test)), y_test_int, fill_alpha=0.8 , color = 'blue', legend_label = "Echantillon test") #données réelles p5.circle(range(len(y_pred)), y_pred_int, fill_alpha=0.4 , color = 'red', legend_label = "Prédiction")#,source=source) p5.plot_width = 900 resu5 = row(column(p5,dico_bokeh), Classification_metrics(clf, X_train,y_train,X_test,y_test, exec_time, blabla5)) #column(blabla5,model_info,pre5,learn)) return resu5
def _setup_text_block(self): """ :return: """ self.text = PreText( text=""" """, style={'font-size': '10pt'}, # width=600, height=450, )
def fknn(X, Y): nomal = PreText(text=" KNN selected") start_time = time.time() X_train, X_test, y_train, y_test = train_test_split(X, Y, train_size=0.8) #List Hyperparameters that we want to tune. leaf_size = list(range(1, 10)) n_neighbors = list(range(1, 10, 2)) p = [1, 2] #Convert to dictionary hyperparameters = dict(leaf_size=leaf_size, n_neighbors=n_neighbors, p=p) #Create new KNN object knn_2 = KNeighborsClassifier() #Fit the model clf = GridSearchCV(knn_2, hyperparameters, cv=10) clf.fit(X_train, y_train) y_pred = clf.predict(X_test) end_time = time.time() exec_time = round(end_time - start_time, 2) #Graphique categ = y_test.astype("category") dico_tmp = dict(enumerate(categ.cat.categories)) dico = dict((v, k) for k, v in dico_tmp.items()) #on converti les categories en entier y_test_int = y_test.map(dico) y_pred_int = pd.Series(y_pred).map(dico) dico_bokeh = Paragraph( text=" Dictionnaire des correspondances (clef, valeur) : \n " + str(dico), width=1000) p7 = figure(title="Prediction de la variable : %s " % select_cible.value, x_axis_label="x", y_axis_label="y") p7.circle(range(len(y_pred)), y_pred_int, fill_alpha=0.8, color='red', legend_label="Prédiction") #,source=source) p7.circle(range(len(y_test)), y_test_int, fill_alpha=0.4, color='blue', legend_label="Echantillon test") #données réelles p7.plot_width = 900 resu3 = row( column(p7, dico_bokeh), Classification_metrics(clf, X_train, y_train, X_test, y_test, exec_time, nomal)) return resu3
def panel(): 'Assemble widgets and plots ' global sample_size_slider, number_of_samples_slider #print(f'panel means: {samples_ar.mean()} {current_sample_ar.mean()}') # kwargs = dict(subtitle= 'Population', plot_height = 160, line_width=3, line_color='grey') text_area = PreText(text=description, width=400) plots = column( plot_rug(pop_cds, subtitle="Distribution of Sample Averages", plot_height = 400, line_color='lightblue'), plot_rug(sample_cds, subtitle='Distribution of All Individuals Sampled.')) s_panel = row(plots, column(sample_size_slider, number_of_samples_slider, text_area, width=400)) return s_panel
def modify_doc(doc): t1 = PreText(height=20, width=200) t2 = PreText(height=20, width=200) t3 = PreText(height=20, width=100) s1 = Slider(start=0, end=len(df), value=0, title='Start') s2 = Slider(start=1, end=len(df) - 1, value=len(df), title='Length') map = figure(plot_width=width, plot_height=height, x_axis_type='mercator', y_axis_type='mercator', match_aspect=True) map.add_tile(TILE) map.circle(x=N.SPHERICAL_MERCATOR_X, y=N.SPHERICAL_MERCATOR_Y, source=df, name='map') elevation = figure(plot_width=width, plot_height=height // 10) elevation.line(x=N.DISTANCE, y=N.ELEVATION, source=df, name='elevation') c = column(row(s1, s2), row(t1, t2, t3), map, elevation) def mkplot(l1, l2): l2 = min(len(df) - 1, l1 + l2) t1.text = '%9.5f,%9.5f' % (df.iloc[l1]['Longitude'], df.iloc[l1]['Latitude']) t2.text = '%9.5f,%9.5f' % (df.iloc[l2]['Longitude'], df.iloc[l2]['Latitude']) t3.text = '%4.2fkm' % ( (df.iloc[l2]['Distance'] - df.iloc[l1]['Distance']) / 1000) get_renderer(map, 'map').data_source.data = df[l1:l2] get_renderer(elevation, 'elevation').data_source.data = df[l1:l2] s1.on_change('value', lambda attr, old, new: mkplot(s1.value, s2.value)) s2.on_change('value', lambda attr, old, new: mkplot(s1.value, s2.value)) doc.add_root(c)
def render_process(pid: int) -> Optional[Model]: process_data = node_data[node_data[PID_KEY] == pid] max_rss = process_data[RSS_KEY].max() avg_cpu = process_data[AVG_CPU_KEY].mean() process = [ p for p in report.cluster.nodes[node.hostname].processes if p.pid == pid ] if not process: logging.warning(f"Process {node.hostname}/{pid} not found in cluster") return process = process[0] range = get_time_range(process_data[DATETIME_KEY]) mib_divisor = 1024.0 * 1024 mem = resample( process_data[RSS_KEY] / mib_divisor, process_data[DATETIME_KEY] ) mem_figure = prepare_time_range_figure(range) mem_figure.yaxis[0].formatter = NumeralTickFormatter() mem_figure.yaxis.axis_label = "RSS (MiB)" mem_figure.y_range = Range1d(0, max_rss / mib_divisor + 100.0) mem_figure.add_tools(HoverTool(tooltips=[("RSS (MiB)", "@rss")])) data = ColumnDataSource(dict(rss=mem, x=mem.index)) mem_figure.line( x="x", y="rss", color="red", legend_label="Memory", source=data ) cpu = resample(process_data[AVG_CPU_KEY], process_data[DATETIME_KEY]) cpu_figure = prepare_time_range_figure(range) cpu_figure.yaxis[0].formatter = NumeralTickFormatter(format="0 %") cpu_figure.yaxis.axis_label = "Avg. CPU usage (%)" cpu_figure.y_range = Range1d(0, 1) cpu_figure.add_tools(HoverTool(tooltips=[("Avg. CPU usage", "@cpu")])) data = ColumnDataSource(dict(cpu=cpu / 100.0, x=cpu.index)) cpu_figure.line( x="x", y="cpu", color="blue", legend_label="CPU usage (%)", source=data ) summary = PreText( text=f""" PID: {pid} Key: {process.key} Max. RSS: {humanize.naturalsize(max_rss, binary=True)} Avg. CPU: {avg_cpu:.02f} % """.strip() ) columns = [summary, mem_figure, cpu_figure] return Panel(child=Column(children=columns), title=process.key)
def _internal_bokeh(doc, example=None): # Note: if launched by package, the result of _internal_example is passed via kwargs random_data_model = example[0] view = example[1] fview = example[2] moduleview = inspect.getsource(sys.modules[__name__]) doc.add_root( layout([[ # we want one row with two columns [PreText(text=moduleview)], [fview.plot, random_data_model.view.table, view.plot], ]]))
def load(): try: bokeh_model = func(*args, **kwargs) # remove spinner and its update try: doc.remove_periodic_callback(progress) except Exception: pass layout.children.append(bokeh_model) layout.children.pop(0) except Exception as e: # exception handling message = PreText(text=f"{type(e)}: {e}\n{format_exc()}") layout.children.append(message)
def modify_doc(doc): t1 = PreText(height=20, width=200) t2 = PreText(height=20, width=200) t3 = PreText(height=20, width=100) s1 = Slider(start=0, end=len(df), value=0, title='Start') s2 = Slider(start=1, end=len(df) - 1, value=len(df), title='Length') f = figure(plot_width=width, plot_height=height, x_axis_type='mercator', y_axis_type='mercator') c = column(row(s1, s2), row(t1, t2, t3), f) def mkplot(l1, l2): l2 = min(len(df) - 1, l1 + l2) t1.text = '%9.5f,%9.5f' % (df.iloc[l1]['Longitude'], df.iloc[l1]['Latitude']) t2.text = '%9.5f,%9.5f' % (df.iloc[l2]['Longitude'], df.iloc[l2]['Latitude']) t3.text = '%4.2fkm' % ( (df.iloc[l2]['Distance'] - df.iloc[l1]['Distance']) / 1000) f = figure(plot_width=width, plot_height=height, x_axis_type='mercator', y_axis_type='mercator') f.add_tile(TILE) f.circle(x='Spherical Mercator X', y='Spherical Mercator Y', source=df[l1:l2]) c.children[2] = f s1.on_change('value', lambda attr, old, new: mkplot(s1.value, s2.value)) s2.on_change('value', lambda attr, old, new: mkplot(s1.value, s2.value)) doc.add_root(c)