我们从Python开源项目中，提取了以下15个代码示例，用于说明如何使用bokeh.plotting.show()。
def plot_waveforms(waveforms, figTitle=''): channels = waveforms.keys() # plot plots = [] for (ct, chan) in enumerate(channels): fig = bk.figure(title=figTitle + repr(chan), plot_width=800, plot_height=350, y_range=[-1.05, 1.05], x_axis_label=u'Time (?s)') fig.background_fill_color = config.plotBackground if config.gridColor: fig.xgrid.grid_line_color = config.gridColor fig.ygrid.grid_line_color = config.gridColor waveformToPlot = waveforms[chan] xpts = np.linspace(0, len(waveformToPlot) / chan.phys_chan.sampling_rate / 1e-6, len(waveformToPlot)) fig.line(xpts, np.real(waveformToPlot), color='red') fig.line(xpts, np.imag(waveformToPlot), color='blue') plots.append(fig) bk.show(column(*plots))
def show(seq): waveforms = build_waveforms(seq) plot_waveforms(waveforms)
def __init__(self, simul, probes, line_kwargs={}, fig_kwargs={}, default_fig_kwargs={"width": 600, "height": 400}, default_line_kwargs={}, notebook=True): from bokeh.io import push_notebook, output_notebook from bokeh.plotting import figure, show, ColumnDataSource from bokeh.layouts import Column if notebook: output_notebook() setattr(self, '_push', push_notebook) self._datasource = ColumnDataSource(dict(t=[simul.t], **{name: [probe(simul.t, simul.fields)] for name, probe in probes.items()})) figs = {} for name, probe in probes.items(): fig_config = default_fig_kwargs.copy() fig_config.update(fig_kwargs.get(name, {})) line_config = default_line_kwargs.copy() line_config.update(line_kwargs.get(name, {})) figs[name] = figure(**fig_config, title=name) figs[name].line('t', name, source=self._datasource, **line_config) self._handler = show(Column(*[figs[name] for name in probes]), notebook_handle=True) self._probes = probes
def show_mpl(**kwargs): plt.show()
def show_mpld3(**kwargs): if not _use_mpld3: raise ImportError("failed to import mpld3: try 'sudo pip install mpld3' or choose another plotting backend") # _mpld3.show(plt.gcf()) _mpld3.save_html(kwargs.get('ax', plt.gcf()), '_mpld3.html') logger.info("opening mpld3 plot in browser") webbrowser.open('_mpld3.html') # TODO: needs to just be input for python3 # raw_input("press enter to continue...") sleep(2) os.remove('_mpld3.html')
def mpl2bokeh(ps, data, plot_inds, **kwargs): """ """ if not conf.devel: raise NotImplementedError("'mpld3' plotting backend not officially supported for this release. Enable developer mode to test.") if not _use_bkh: raise ImportError("failed to import bokeh: try 'sudo pip install bokeh' or choose another plotting backend") if not _use_mpl: raise ImportError("failed to import matplotlib: try 'sudo pip install matplotlib' or choose another plotting backend") # mpl2bokeh compiles everything through matplotlib and tries to convert # only when calling show return mpl(ps, data, plot_inds, **kwargs)
def show_bokeh(**kwargs): if not _use_bkh: raise ImportError("failed to import bokeh: try 'sudo pip install bokeh' or choose another plotting backend") bkh.show(kwargs['ax']) # TODO: needs to just be input for python3 # raw_input("press enter to contisnue...") sleep(2) os.remove('_bkh.html')
def lightning(ps, data, plot_inds, **kwargs): """ """ if not conf.devel: raise NotImplementedError("'mpld3' plotting backend not officially supported for this release. Enable developer mode to test.") try: from lightning import Lightning except ImportError: raise ImportError("failed to import lightning: try 'sudo pip install lightning-python' or choose another plotting backend") _use_lgn = False else: _use_lgn = True # TODO: option to use server instead of local (for sharing links, etc) lgn = Lightning(local=True) logger.warning("lightning plotting backend is VERY EXPERIMENTAL (read: non-existant)") # it looks like all calls for a single figure need to be made at once by giving lists # TODO: look into streaming option to stream fits as fitting or as sampling??? series = np.random.randn(5, 50) viz = lgn.line(series) # TODO: return and accept viz and then write a .show() function? viz.save_html('_lgn.html', overwrite=True) return None, []
def db_plot(*args, **kwargs): # plot utility for debugging plt.plot(*args, **kwargs) plt.show() pause(1)
def setup_dashboard(self): output_notebook() x = [0, 1, 1, 2, 2, 3, 3, 4] y = 8*[10 ** -7] source = ColumnDataSource(data=dict(x=x, y=y)) plot = figure(plot_width=300, plot_height=150, y_axis_type="log", y_range=[0.0000000001, 1], x_range=[0, 4], x_axis_label='Epoch', y_axis_label='Learning Rate') plot.line('x', 'y', source=source, line_width=3, line_alpha=0.6) learn_inputs = 4 * [3] base_code = """ var data = source.data; var f = cb_obj.value x = data['x'] y = data['y'] y[{}] = Math.pow(10.0, -1.0 * (10-f)) y[{}] = Math.pow(10.0, -1.0 * (10-f)) source.trigger('change'); var command = 'dashboard.learn_inputs[{}] = ' + f; var kernel = IPython.notebook.kernel; kernel.execute(command) """ # set up figure fig = figure(name="cost", y_axis_label="Cost", x_range=(0, 4), x_axis_label="Epoch", plot_width=300, plot_height=300) self.fig = fig train_source = ColumnDataSource(data=dict(x=[], y=[])) train_cost = fig.line('x', 'y', source=train_source) self.train_source = train_source val_source = ColumnDataSource(data=dict(x=[], y=[])) val_cost = fig.line('x', 'y', source=val_source, color='red') self.val_source = val_source # set up sliders and callback callbacks = [CustomJS(args=dict(source=source), code=base_code.format(k, k+1, k/2)) for k in [0, 2, 4, 6]] slider = [Slider(start=0.1, end=10, value=3, step=.1, title=None, callback=C, orientation='vertical', width=80, height=50) for C in callbacks] radio_group = RadioGroup(labels=[""], active=0, width=65) def train_model_button(run=True): train_model(slider, fig=fig, handle=fh, train_source=train_source, val_source=val_source) sliders = row(radio_group, slider[0], slider[1], slider[2], slider[3]) settings = column(plot, sliders) layout = gridplot([[settings, fig]], sizing_mode='fixed', merge_tools=True, toolbar_location=None) self.fh = show(layout, notebook_handle=True)
def _process_batch(self, param, name): if self.handle is None: self.handle = show(self.fig, notebook_handle=True) now = default_timer() # print "{}_{}".format(param.nbatch, param.epoch) if param.nbatch == 0: self.epoch = self.epoch + 1 time = float(param.nbatch) / self.total + param.epoch if param.eval_metric is not None: name_value = param.eval_metric.get_name_value() param.eval_metric.reset() cost = name_value[0][1] if name == 'train': cost = self.get_average_cost(cost) if math.isnan(cost) or cost > 4000: cost = 4000 if name == 'train': self.train_source.data['x'].append(time) self.train_source.data['y'].append(cost) elif name == 'eval': self.val_source.data['x'].append(param.epoch+1) self.val_source.data['y'].append(cost) if (now - self.last_update > self.update_thresh_s): self.last_update = now if self.handle is not None: push_notebook(handle=self.handle) else: push_notebook()
def __init__(self, linenames, sessionname=None, colors=None, xaxis='iterations', callevery=1): """ :type linenames: list or tuple :param linenames: Names of the time series for the Bokeh server to plot. The call method must have the names in the list as keyword arguments. :type sessionname: str :param sessionname: Name of the Bokeh session :type xaxis: str :param xaxis: What goes in the x axis ('iterations' or 'epochs') """ super(plotter, self).__init__(callevery=callevery) # Meta self.linenames = list(linenames) self.sessionname = "PlotterID-{}".format(id(self)) if sessionname is None else sessionname self.colors = colors if colors is not None else [None,] * len(self.linenames) self.xaxis = xaxis # Init plot server bplt.output_server(self.sessionname) # Build figure self.figure = bplt.figure() self.figure.xaxis.axis_label = self.xaxis # Make lines in figure for name, color in zip(self.linenames, self.colors): if color is not None: self.figure.line(x=[], y=[], name=name, color=color, legend=name) else: self.figure.line(x=[], y=[], name=name, legend=name) bplt.show(self.figure) # Make list of renderers and datasources self.renderers = {name: self.figure.select(dict(name=name)) for name in self.linenames} self.datasources = {name: self.renderers[name][0].data_source for name in self.linenames}
def __init__(self, simul, keys=None, line_kwargs={}, fig_kwargs={}, default_fig_kwargs={"width": 600, "height": 400}, default_line_kwargs={}, notebook=True, stack=False): from bokeh.io import push_notebook, output_notebook from bokeh.plotting import figure, show, ColumnDataSource from bokeh.layouts import Column if notebook: output_notebook() setattr(self, '_push', push_notebook) keys = keys if keys else [ key for key in simul.fields.keys() if key != 'x'] self._datafunc = {'x': lambda t, fields, key: fields.x} for key in keys: if isinstance(key, str): self._datafunc[key] = lambda t, fields, key: fields[key] if isinstance(key, (tuple, list)): self._datafunc[key[0]] = key[1] self._datasource = ColumnDataSource({key: func(simul.t, simul.fields, key) for (key, func) in self._datafunc.items()}) self.keys = list(self._datafunc.keys()) self.keys.remove("x") if stack: fig = figure(**default_fig_kwargs) for key in self.keys: line_config = default_line_kwargs.copy() line_config.update(line_kwargs.get(key, {})) fig.line('x', key, source=self._datasource, **line_kwargs.get(key, {})) self._handler = show(fig, notebook_handle=True) return else: figs = {} for key in self.keys: fig_config = default_fig_kwargs.copy() fig_config.update(fig_kwargs.get(key, {})) line_config = default_line_kwargs.copy() line_config.update(line_kwargs.get(key, {})) figs[key] = figure(**fig_config, title=key) figs[key].line('x', key, source=self._datasource, **line_config) self._handler = show(Column(*[figs[key] for key in self._datafunc.keys() if key != 'x']), notebook_handle=True)
def scatter_with_hover(x, y, in_notebook=True, show_plt=True, fig=None, name=None, marker='o', fig_width=500, fig_height=500, x_label=None, y_label=None, title=None, color="blue"): """ Plots an interactive scatter plot of `x` vs `y` using bokeh, with automatic tooltips showing columns from `df`. Modified from: http://blog.rtwilson.com/bokeh-plots-with-dataframe-based-tooltips/ Args: x (numpy.ndarray): The data for the x-axis. y (numpy.ndarray): The data for the y-axis. fig (bokeh.plotting.Figure, optional): Figure on which to plot (if not given then a new figure will be created) name (str, optional): Series name to give to the scattered data marker (str, optional): Name of marker to use for scatter plot Returns: fig (bokeh.plotting.Figure): Figure (the same as given, or the newly created figure) if show is False """ # Make it so it works for ipython. if in_notebook: #pragma: no cover output_notebook() # insert the correct hover identifier. hover = HoverTool(tooltips=[("entry#", "@label"),]) # If we haven't been given a Figure obj then create it with default # size etc. if fig is None: # if title is None: # fig = figure(width=fig_width, height=fig_height, tools=['box_zoom', 'reset',hover]) # else: fig = figure(width=fig_width, height=fig_height, tools=['box_zoom', 'reset',hover],title=title) # We're getting data from the given dataframe source = ColumnDataSource(data=dict(x=x,y=y,label=range(1,len(x)+1))) # Actually do the scatter plot - the easy bit # (other keyword arguments will be passed to this function) fig.scatter('x', 'y', source=source, marker=marker,color=color,name=name) if x_label is not None: fig.xaxis.axis_label = x_label if y_label is not None: fig.yaxis.axis_label = y_label if show_plt: # pragma: no cover show(fig) else: return(fig)
def scatter(x,y,show_plt=True, x_label=None, y_label=None, label=None, title=None,fig=None,ax=None): """Make a standard matplotlib style scatter plot. Args: x (numpy.ndarray): The data for the x-axis. y (numpy.ndarray): The data for the y-axis. show (bool, optional): True if plot is to be shown. x_label (str, optional): The x-axis label. y_label (str, optional): The y-axis label. label (str, optional): The data trend label. title (str, optional): The plot title. fig (matplotlib.figure.Figure, optional): An initial figure to add points too. ax (matplotlib.axes._subplots.AxesSubplot, optional): A subplot object to plot on. Returns: fig (matplotlib object): Returns the matplotlib object if show = False. """ if fig is None and ax is None: fig = plt.figure() elif ax is None: fig = fig else: ax = ax if not isinstance(x,np.ndarray): #pragma: no cover x = np.array(x) if not isinstance(y,np.ndarray): #pragma: no cover y = np.array(y) if ax is None: if label is not None: plt.scatter(x,y,label=label) else: plt.scatter(x,y) if x_label is not None: plt.xlabel(x_label) if y_label is not None: plt.ylabel(y_label) if title is not None: plt.title(title) else: if label is not None: ax.scatter(x,y,label=label) else: ax.scatter(x,y) if x_label is not None: ax.set_xlabel(x_label) if y_label is not None: ax.set_ylabel(y_label) if title is not None: ax.set_title(title) return ax if show_plt is True: #pragma: no cover plt.show() else: return fig
