def get(n,b): r = [] now = datetime.datetime.now() t = str(now.strftime("%Y,%m,%d")) y = int(t[0:4]) m = int(t[6]) d = int(t[8:10]) start=datetime.datetime(2019,1,1) end=datetime.datetime(y,m,d) d = data.DataReader(name=n,data_source="yahoo",start=start,end=end) def inc_dec(c,o): if c > o: value = "Increase" elif c < o: value = "Decrease" else: value = "Equal" return value d["Status"] = [inc_dec(c,o) for c,o in zip(d.Close,d.Open)] d["Middle"] = (d.Open + d.Close)/2 d["Height"] = abs(d.Close-d.Open) p = figure(x_axis_type='datetime', width=1000, height=245,sizing_mode="scale_width") p.yaxis.axis_label = 'usd' t = Title() p.title= t p.grid.grid_line_alpha = 0.3 hours_12 = 12*60*60*1000 p.segment(d.index,d.High,d.index,d.Low,color="black") p.rect(d.index[d.Status=="Increase"],d.Middle[d.Status=="Increase"], hours_12,d.Height[d.Status=="Increase"],fill_color='#CCFFFF',line_color="black") p.rect(d.index[d.Status=="Decrease"],d.Middle[d.Status=="Decrease"], hours_12,d.Height[d.Status=="Decrease"],fill_color='#FF3333',line_color="black") script, div = components(p) cdn_js=CDN.js_files[0] cdn_css=CDN.css_files[0] re = [script,div,n,b,cdn_js,cdn_css] return re
def plot_bpv( ax, length_plotters, rows, cols, obs_plotters, pp_plotters, total_pp_samples, kind, t_stat, bpv, plot_mean, reference, mse, n_ref, hdi_prob, color, figsize, textsize, labeller, plot_ref_kwargs, backend_kwargs, show, ): """Bokeh bpv plot.""" if backend_kwargs is None: backend_kwargs = {} backend_kwargs = { **backend_kwarg_defaults(), **backend_kwargs, } color = vectorized_to_hex(color) if plot_ref_kwargs is None: plot_ref_kwargs = {} if kind == "p_value" and reference == "analytical": plot_ref_kwargs.setdefault("line_color", "black") plot_ref_kwargs.setdefault("line_dash", "dashed") else: plot_ref_kwargs.setdefault("alpha", 0.1) plot_ref_kwargs.setdefault("line_color", color) (figsize, ax_labelsize, _, _, linewidth, markersize) = _scale_fig_size(figsize, textsize, rows, cols) if ax is None: axes = create_axes_grid( length_plotters, rows, cols, figsize=figsize, backend_kwargs=backend_kwargs, ) else: axes = np.atleast_2d(ax) if len([item for item in axes.ravel() if not None]) != length_plotters: raise ValueError( "Found {} variables to plot but {} axes instances. They must be equal." .format(length_plotters, len(axes))) for i, ax_i in enumerate( (item for item in axes.flatten() if item is not None)): var_name, sel, isel, obs_vals = obs_plotters[i] pp_var_name, _, _, pp_vals = pp_plotters[i] obs_vals = obs_vals.flatten() pp_vals = pp_vals.reshape(total_pp_samples, -1) if obs_vals.dtype.kind == "i" or pp_vals.dtype.kind == "i": obs_vals, pp_vals = smooth_data(obs_vals, pp_vals) if kind == "p_value": tstat_pit = np.mean(pp_vals <= obs_vals, axis=-1) x_s, tstat_pit_dens = kde(tstat_pit) ax_i.line(x_s, tstat_pit_dens, line_width=linewidth, line_color=color) if reference is not None: dist = stats.beta(obs_vals.size / 2, obs_vals.size / 2) if reference == "analytical": lwb = dist.ppf((1 - 0.9999) / 2) upb = 1 - lwb x = np.linspace(lwb, upb, 500) dens_ref = dist.pdf(x) ax_i.line(x, dens_ref, **plot_ref_kwargs) elif reference == "samples": x_ss, u_dens = sample_reference_distribution( dist, ( tstat_pit_dens.size, n_ref, ), ) ax_i.multi_line(list(x_ss.T), list(u_dens.T), line_width=linewidth, **plot_ref_kwargs) elif kind == "u_value": tstat_pit = np.mean(pp_vals <= obs_vals, axis=0) x_s, tstat_pit_dens = kde(tstat_pit) ax_i.line(x_s, tstat_pit_dens, color=color) if reference is not None: if reference == "analytical": n_obs = obs_vals.size hdi_ = stats.beta(n_obs / 2, n_obs / 2).ppf( (1 - hdi_prob) / 2) hdi_odds = (hdi_ / (1 - hdi_), (1 - hdi_) / hdi_) ax_i.add_layout( BoxAnnotation( bottom=hdi_odds[1], top=hdi_odds[0], fill_alpha=plot_ref_kwargs.pop("alpha"), fill_color=plot_ref_kwargs.pop("line_color"), **plot_ref_kwargs, )) ax_i.line([0, 1], [1, 1], line_color="white") elif reference == "samples": dist = stats.uniform(0, 1) x_ss, u_dens = sample_reference_distribution( dist, (tstat_pit_dens.size, n_ref)) for x_ss_i, u_dens_i in zip(x_ss.T, u_dens.T): ax_i.line(x_ss_i, u_dens_i, line_width=linewidth, **plot_ref_kwargs) if mse: ax_i.line(0, 0, legend_label= f"mse={np.mean((1 - tstat_pit_dens)**2) * 100:.2f}") ax_i.line(0, 0) else: if t_stat in ["mean", "median", "std"]: if t_stat == "mean": tfunc = np.mean elif t_stat == "median": tfunc = np.median elif t_stat == "std": tfunc = np.std obs_vals = tfunc(obs_vals) pp_vals = tfunc(pp_vals, axis=1) elif hasattr(t_stat, "__call__"): obs_vals = t_stat(obs_vals.flatten()) pp_vals = t_stat(pp_vals) elif is_valid_quantile(t_stat): t_stat = float(t_stat) obs_vals = np.quantile(obs_vals, q=t_stat) pp_vals = np.quantile(pp_vals, q=t_stat, axis=1) else: raise ValueError(f"T statistics {t_stat} not implemented") plot_kde(pp_vals, ax=ax_i, plot_kwargs={"color": color}, backend="bokeh", show=False) # ax_i.set_yticks([]) if bpv: p_value = np.mean(pp_vals <= obs_vals) ax_i.line(0, 0, legend_label=f"bpv={p_value:.2f}", alpha=0) if plot_mean: ax_i.circle(obs_vals.mean(), 0, fill_color=color, line_color="black", size=markersize) _title = Title() _title.text = labeller.make_pp_label(var_name, pp_var_name, sel, isel) ax_i.title = _title size = str(int(ax_labelsize)) ax_i.title.text_font_size = f"{size}pt" show_layout(axes, show) return axes
def tweets_per_hour_plot(self, data_path, emotion=None, color="#b3de69"): #data_path = os.path.dirname(__file__) + "/../data/pbFollowers/merged/" data_path = data_path + "merged/" dir_files = os.listdir(data_path) counts_of_tweets = {} for filename in dir_files: #df = pd.read_json(data_path + filename) df = self.get_flattened_data(data_path + filename, 'tones', ['user', 'created_at']) if emotion is not None: try: df = df[df.tone_name == emotion] except AttributeError: continue try: df['created_at'] = df['created_at'] / 1000 except TypeError: print("\'Created_at\' error where it is somehow a dict") continue offset = 0 try: offset = df['user'][0]['utc_offset'] except (IndexError, KeyError): offset = 0 if offset is None: offset = 0 #df['std_time'] = df['created_at'] + pd.TimedeltaIndex(df['offset'], unit='s') df['std_time'] = df['created_at'] + offset df['std_time'] = [ datetime.datetime.fromtimestamp(x) for x in df['std_time'] ] df = df.set_index(df['std_time']) temp = pd.DatetimeIndex(df['std_time']) df['hour'] = temp.hour p = df.groupby(df['hour']) freq_of_tweets = p['std_time'].count() freq_dict = freq_of_tweets.to_dict() for key, value in freq_dict.items(): try: counts_of_tweets[key] += value except KeyError: counts_of_tweets[key] = value hours = np.fromiter(counts_of_tweets.keys(), dtype=float) hours += 1 numTweets = np.fromiter(counts_of_tweets.values(), dtype=float) # output to static HTML file if emotion is None: hourly_freq_plot_path = data_path + "../plots/Hourly_freq_plot.html" output_file(hourly_freq_plot_path) source = ColumnDataSource(data=dict(hours=hours, numTweets=numTweets)) hover = HoverTool(tooltips=[ ('hours', '@hours'), ('numTweets', '@numTweets'), ]) xdr = DataRange1d() ydr = DataRange1d() plot = Plot(x_range=xdr, y_range=ydr, plot_width=500, plot_height=500, h_symmetry=False, v_symmetry=False, min_border=0, tools=[hover]) glyph = VBar(x="hours", top="numTweets", bottom=0, width=0.5, fill_color=color) plot.add_glyph(source, glyph) xaxis = LinearAxis() plot.add_layout(xaxis, 'below') yaxis = LinearAxis() plot.add_layout(yaxis, 'left') t = Title() if emotion is not None: t.text = "(" + emotion + ") Number of Tweets by Hour" else: t.text = "(all emotions) Number of Tweets by Hour" plot.title = t plot.xaxis.axis_label = 'Hours' plot.yaxis.axis_label = 'Number of Tweets' if emotion is not None: return plot else: show(plot) return plot
def plot(): from pandas_datareader import data import datetime from bokeh.plotting import figure, show, output_file from bokeh.models.annotations import Title # from bokeh.io import show, output_file from bokeh.embed import components from bokeh.resources import CDN start = datetime.datetime(2020, 7, 23) end = datetime.datetime(2021, 1, 23) df = data.DataReader(name="TSLA", data_source="yahoo", start=start, end=end) def inc_dec(c, o): if c > o: value = "Increase" elif c < o: value = "Decrease" else: value = "Equal" return value df['Status'] = [inc_dec(c, o) for c, o in zip(df.Close, df.Open)] df["Middle"] = (df.Open + df.Close) / 2 df["Height"] = abs(df.Close - df.Open) p = figure(x_axis_type='datetime', width=800, height=300, sizing_mode='scale_width') t = Title() t.text = "Tesla Candlestick Chart 7/23/2020 - 1/23/2021" p.title = t p.grid.grid_line_alpha = 0.3 hours_12 = 12 * 60 * 60 * 1000 p.segment(df.index, df.High, df.index, df.Low, color="black") p.rect(df.index[df.Status == "Increase"], df.Middle[df.Status == "Increase"], hours_12, df.Height[df.Status == "Increase"], fill_color="green", line_color="black") p.rect(df.index[df.Status == "Decrease"], df.Middle[df.Status == "Decrease"], hours_12, df.Height[df.Status == "Decrease"], fill_color="red", line_color="black") script1, div1 = components(p) cdn_js = CDN.js_files[0] cdn_css = CDN.css_files return render_template("plot.html", script1=script1, div1=div1, cdn_css=cdn_css, cdn_js=cdn_js)
def plot(): from pandas_datareader import data import datetime from bokeh.plotting import figure, show, output_file from bokeh.models.annotations import Title from bokeh.embed import components from bokeh.resources import CDN start = datetime.datetime(2015, 11, 1) end = datetime.datetime(2016, 3, 10) df = data.DataReader(name='GOOG', data_source='yahoo', start=start, end=end) def inc_dec(c, o): if c > o: value = "Increase" elif c < o: value = "Decrease" else: value = "Equal" return value df["Status"] = [inc_dec(c, o) for c, o in zip(df.Close, df.Open)] df["Middle"] = (df.Open + df.Close) / 2 df["Height"] = abs(df.Close - df.Open) p = figure(x_axis_type='datetime', width=1000, height=300, sizing_mode="scale_width") a = Title() a.text = "Candlestick Chart" p.title = a p.grid.grid_line_alpha = 0.3 #Define rectangles for gray parts of candlestick chart, pass x and y coords of center, as well as length and width hours_12 = 12 * 60 * 60 * 1000 p.segment(df.index, df.High, df.index, df.Low, color="Black") p.rect(df.index[df.Status == 'Increase'], df.Middle[df.Status == "Increase"], hours_12, df.Height[df.Status == "Increase"], fill_color='green', line_color='black') p.rect(df.index[df.Status == 'Decrease'], df.Middle[df.Status == "Decrease"], hours_12, df.Height[df.Status == "Decrease"], fill_color='red', line_color='black') script1, div1 = components(p) cdn_js = CDN.js_files[0] cdn_css = CDN.css_files[0] return render_template("plot.html", script1=script1, div1=div1, cdn_css=cdn_css, cdn_js=cdn_js) output_file('CS.html') show(p)
def plot_trace( data, var_names, divergences, kind, figsize, rug, lines, circ_var_names, # pylint: disable=unused-argument circ_var_units, # pylint: disable=unused-argument compact, compact_prop, combined, chain_prop, legend, labeller, plot_kwargs, fill_kwargs, rug_kwargs, hist_kwargs, trace_kwargs, rank_kwargs, plotters, divergence_data, axes, backend_kwargs, backend_config, show, ): """Bokeh traceplot.""" # If divergences are plotted they must be provided if divergences is not False: assert divergence_data is not None if backend_config is None: backend_config = {} backend_config = { **backend_kwarg_defaults(("bounds_y_range", "plot.bokeh.bounds_y_range"), ), **backend_config, } # Set plot default backend kwargs if backend_kwargs is None: backend_kwargs = {} backend_kwargs = { **backend_kwarg_defaults(("dpi", "plot.bokeh.figure.dpi"), ), **backend_kwargs, } dpi = backend_kwargs.pop("dpi") if figsize is None: figsize = (12, len(plotters) * 2) figsize, _, _, _, linewidth, _ = _scale_fig_size(figsize, 10, rows=len(plotters), cols=2) backend_kwargs.setdefault("height", int(figsize[1] * dpi // len(plotters))) backend_kwargs.setdefault("width", int(figsize[0] * dpi // 2)) if lines is None: lines = () num_chain_props = len(data.chain) + 1 if combined else len(data.chain) if not compact: chain_prop = ({ "line_color": plt.rcParams["axes.prop_cycle"].by_key()["color"] } if chain_prop is None else chain_prop) else: chain_prop = ({ "line_dash": ("solid", "dotted", "dashed", "dashdot"), } if chain_prop is None else chain_prop) compact_prop = ({ "line_color": plt.rcParams["axes.prop_cycle"].by_key()["color"] } if compact_prop is None else compact_prop) if isinstance(chain_prop, str): chain_prop = { chain_prop: plt.rcParams["axes.prop_cycle"].by_key()[chain_prop] } if isinstance(chain_prop, tuple): warnings.warn( "chain_prop as a tuple will be deprecated in a future warning, use a dict instead", FutureWarning, ) chain_prop = {chain_prop[0]: chain_prop[1]} chain_prop = { prop_name: [prop for _, prop in zip(range(num_chain_props), cycle(props))] for prop_name, props in chain_prop.items() } if isinstance(compact_prop, str): compact_prop = { compact_prop: plt.rcParams["axes.prop_cycle"].by_key()[compact_prop] } if isinstance(compact_prop, tuple): warnings.warn( "compact_prop as a tuple will be deprecated in a future warning, use a dict instead", FutureWarning, ) compact_prop = {compact_prop[0]: compact_prop[1]} trace_kwargs = {} if trace_kwargs is None else trace_kwargs trace_kwargs.setdefault("alpha", 0.35) if hist_kwargs is None: hist_kwargs = {} hist_kwargs.setdefault("alpha", 0.35) if plot_kwargs is None: plot_kwargs = {} if fill_kwargs is None: fill_kwargs = {} if rug_kwargs is None: rug_kwargs = {} if rank_kwargs is None: rank_kwargs = {} trace_kwargs.setdefault("line_width", linewidth) plot_kwargs.setdefault("line_width", linewidth) if rank_kwargs is None: rank_kwargs = {} if axes is None: axes = [] backend_kwargs_copy = backend_kwargs.copy() for i in range(len(plotters)): if not i: _axes = [ bkp.figure(**backend_kwargs), bkp.figure(**backend_kwargs_copy) ] backend_kwargs_copy.setdefault("x_range", _axes[1].x_range) else: _axes = [ bkp.figure(**backend_kwargs), bkp.figure(**backend_kwargs_copy), ] axes.append(_axes) axes = np.atleast_2d(axes) cds_data = {} cds_var_groups = {} draw_name = "draw" for var_name, selection, isel, value in list( xarray_var_iter(data, var_names=var_names, combined=True)): if selection: cds_name = "{}_ARVIZ_CDS_SELECTION_{}".format( var_name, "_".join( str(item) for key, value in selection.items() for item in ([key, value] if ( isinstance(value, str) or not isinstance(value, Iterable)) else [key, *value])), ) else: cds_name = var_name if var_name not in cds_var_groups: cds_var_groups[var_name] = [] cds_var_groups[var_name].append(cds_name) for chain_idx, _ in enumerate(data.chain.values): if chain_idx not in cds_data: cds_data[chain_idx] = {} _data = value[chain_idx] cds_data[chain_idx][cds_name] = _data while any(key == draw_name for key in cds_data[0]): draw_name += "w" for chain_idx in cds_data: cds_data[chain_idx][draw_name] = data.draw.values cds_data = { chain_idx: ColumnDataSource(cds) for chain_idx, cds in cds_data.items() } for idx, (var_name, selection, isel, value) in enumerate(plotters): value = np.atleast_2d(value) if len(value.shape) == 2: y_name = (var_name if not selection else "{}_ARVIZ_CDS_SELECTION_{}".format( var_name, "_".join( str(item) for key, value in selection.items() for item in ((key, value) if ( isinstance(value, str) or not isinstance(value, Iterable)) else ( key, *value))), )) if rug: rug_kwargs["y"] = y_name _plot_chains_bokeh( ax_density=axes[idx, 0], ax_trace=axes[idx, 1], data=cds_data, x_name=draw_name, y_name=y_name, chain_prop=chain_prop, combined=combined, rug=rug, kind=kind, legend=legend, trace_kwargs=trace_kwargs, hist_kwargs=hist_kwargs, plot_kwargs=plot_kwargs, fill_kwargs=fill_kwargs, rug_kwargs=rug_kwargs, rank_kwargs=rank_kwargs, ) else: for y_name in cds_var_groups[var_name]: if rug: rug_kwargs["y"] = y_name _plot_chains_bokeh( ax_density=axes[idx, 0], ax_trace=axes[idx, 1], data=cds_data, x_name=draw_name, y_name=y_name, chain_prop=chain_prop, combined=combined, rug=rug, kind=kind, legend=legend, trace_kwargs=trace_kwargs, hist_kwargs=hist_kwargs, plot_kwargs=plot_kwargs, fill_kwargs=fill_kwargs, rug_kwargs=rug_kwargs, rank_kwargs=rank_kwargs, ) for col in (0, 1): _title = Title() _title.text = labeller.make_label_vert(var_name, selection, isel) axes[idx, col].title = _title axes[idx, col].y_range = DataRange1d( bounds=backend_config["bounds_y_range"], min_interval=0.1) for _, _, vlines in (j for j in lines if j[0] == var_name and j[1] == selection): if isinstance(vlines, (float, int)): line_values = [vlines] else: line_values = np.atleast_1d(vlines).ravel() for line_value in line_values: vline = Span( location=line_value, dimension="height", line_color="black", line_width=1.5, line_alpha=0.75, ) hline = Span( location=line_value, dimension="width", line_color="black", line_width=1.5, line_alpha=trace_kwargs["alpha"], ) axes[idx, 0].renderers.append(vline) axes[idx, 1].renderers.append(hline) if legend: for col in (0, 1): axes[idx, col].legend.location = "top_left" axes[idx, col].legend.click_policy = "hide" else: for col in (0, 1): if axes[idx, col].legend: axes[idx, col].legend.visible = False if divergences: div_density_kwargs = {} div_density_kwargs.setdefault("size", 14) div_density_kwargs.setdefault("line_color", "red") div_density_kwargs.setdefault("line_width", 2) div_density_kwargs.setdefault("line_alpha", 0.50) div_density_kwargs.setdefault("angle", np.pi / 2) div_trace_kwargs = {} div_trace_kwargs.setdefault("size", 14) div_trace_kwargs.setdefault("line_color", "red") div_trace_kwargs.setdefault("line_width", 2) div_trace_kwargs.setdefault("line_alpha", 0.50) div_trace_kwargs.setdefault("angle", np.pi / 2) div_selection = { k: v for k, v in selection.items() if k in divergence_data.dims } divs = divergence_data.sel(**div_selection).values divs = np.atleast_2d(divs) for chain, chain_divs in enumerate(divs): div_idxs = np.arange(len(chain_divs))[chain_divs] if div_idxs.size > 0: values = value[chain, div_idxs] tmp_cds = ColumnDataSource({"y": values, "x": div_idxs}) if divergences == "top": y_div_trace = value.max() else: y_div_trace = value.min() glyph_density = Dash(x="y", y=0.0, **div_density_kwargs) if kind == "trace": glyph_trace = Dash(x="x", y=y_div_trace, **div_trace_kwargs) axes[idx, 1].add_glyph(tmp_cds, glyph_trace) axes[idx, 0].add_glyph(tmp_cds, glyph_density) show_layout(axes, show) return axes
def forestplot(self, credible_interval, quartiles, linewidth, markersize, ax, rope): """Draw forestplot for each plotter. Parameters ---------- credible_interval : float How wide each line should be quartiles : bool Whether to mark quartiles linewidth : float Width of forestplot line markersize : float Size of marker in center of forestplot line ax : Axes Axes to draw on """ if rope is None or isinstance(rope, dict): pass elif len(rope) == 2: cds = ColumnDataSource( { "x": rope, "lower": [-2 * self.y_max(), -2 * self.y_max()], "upper": [self.y_max() * 2, self.y_max() * 2], } ) band = Band( base="x", lower="lower", upper="upper", fill_color=[ color for _, color in zip( range(4), cycle(plt.rcParams["axes.prop_cycle"].by_key()["color"]) ) ][2], line_alpha=0.5, source=cds, ) ax.renderers.append(band) else: raise ValueError( "Argument `rope` must be None, a dictionary like" '{"var_name": {"rope": (lo, hi)}}, or an ' "iterable of length 2" ) # Quantiles to be calculated endpoint = 100 * (1 - credible_interval) / 2 if quartiles: qlist = [endpoint, 25, 50, 75, 100 - endpoint] else: qlist = [endpoint, 50, 100 - endpoint] for plotter in self.plotters.values(): for y, rope_var, values, color in plotter.treeplot(qlist, credible_interval): if isinstance(rope, dict): self.display_multiple_ropes(rope, ax, y, linewidth, rope_var) mid = len(values) // 2 param_iter = zip( np.linspace(2 * linewidth, linewidth, mid, endpoint=True)[-1::-1], range(mid) ) for width, j in param_iter: ax.line( [values[j], values[-(j + 1)]], [y, y], line_width=width, line_color=color ) ax.circle( x=values[mid], y=y, size=markersize * 0.75, fill_color=color, ) _title = Title() _title.text = "{:.1%} Credible Interval".format(credible_interval) ax.title = _title return ax
def _d_helper( vec, vname, color, bw, line_width, markersize, credible_interval, point_estimate, hpd_markers, outline, shade, ax, data_label, ): extra = dict() if data_label is not None: extra["legend_label"] = data_label if vec.dtype.kind == "f": if credible_interval != 1: hpd_ = hpd(vec, credible_interval, multimodal=False) new_vec = vec[(vec >= hpd_[0]) & (vec <= hpd_[1])] else: new_vec = vec density, xmin, xmax = _fast_kde(new_vec, bw=bw) density *= credible_interval x = np.linspace(xmin, xmax, len(density)) ymin = density[0] ymax = density[-1] if outline: ax.line(x, density, line_color=color, line_width=line_width, **extra) ax.line( [xmin, xmin], [-ymin / 100, ymin], line_color=color, line_dash="solid", line_width=line_width, ) ax.line( [xmax, xmax], [-ymax / 100, ymax], line_color=color, line_dash="solid", line_width=line_width, ) if shade: ax.patch(np.r_[x[::-1], x, x[-1:]], np.r_[np.zeros_like(x), density, [0]], fill_color=color, fill_alpha=shade, **extra) else: xmin, xmax = hpd(vec, credible_interval, multimodal=False) bins = range(xmin, xmax + 2) _, hist, edges = histogram(vec, bins=bins) if outline: ax.quad(top=hist, bottom=0, left=edges[:-1], right=edges[1:], line_color=color, fill_color=None, **extra) else: ax.quad(top=hist, bottom=0, left=edges[:-1], right=edges[1:], line_color=color, fill_color=color, fill_alpha=shade, **extra) if hpd_markers: ax.diamond(xmin, 0, line_color="black", fill_color=color, size=markersize) ax.diamond(xmax, 0, line_color="black", fill_color=color, size=markersize) if point_estimate is not None: if point_estimate == "mean": est = np.mean(vec) elif point_estimate == "median": est = np.median(vec) ax.circle(est, 0, fill_color=color, line_color="black", size=markersize) _title = Title() _title.text = vname ax.title = _title
items.append(a[1]) count = Counter(items) result = {} """ for x in count.keys(): result = {months[int(x)]: count[x]} print count[x] #birthday.update({person: date}) """ result = {months[int(x)]: count[x] for x in count.keys()} print(result.keys()) output_file("plot.html") categories = list(months.values()) print(categories) x = list(result.keys()) y = list(count.values()) p = figure(x_range=categories) p.vbar(x=x, top=y, width=0.5) p.xaxis.axis_label = 'Miesiace' p.yaxis.axis_label = 'Liczba naukowcow' t = Title() t.text = 'Moja figura' p.title = t show(p) """ for x in birthday.keys(): type(x.encode('utf-8')) """
} geomap.patches(**patches_opts) ##create chart chart_opts = { 'plot_width':840, 'plot_height':350, 'tools':'', 'x_axis_type': 'datetime', 'output_backend': 'webgl', 'title': '', } chart = figure(**chart_opts) chart_title = Title() chart_title.text = "starting title" chart.title = chart_title chart_wheel_zoom = WheelZoomTool() chart_pan_tool = PanTool() chart.add_tools(chart_wheel_zoom, chart_pan_tool) chart.toolbar.active_scroll = chart_wheel_zoom chart.xaxis.visible = False chart_lines = None chart_hover = None chart.toolbar.logo = None chart.toolbar_location = None
def plot_posterior( ax, length_plotters, rows, cols, figsize, plotters, bw, circular, bins, kind, point_estimate, round_to, hdi_prob, multimodal, skipna, textsize, ref_val, rope, kwargs, backend_kwargs, show, ): """Bokeh posterior plot.""" if backend_kwargs is None: backend_kwargs = {} backend_kwargs = { **backend_kwarg_defaults(("dpi", "plot.bokeh.figure.dpi"), ), **backend_kwargs, } (figsize, ax_labelsize, *_, linewidth, _) = _scale_fig_size(figsize, textsize, rows, cols) if ax is None: ax = create_axes_grid( length_plotters, rows, cols, figsize=figsize, backend_kwargs=backend_kwargs, ) else: ax = np.atleast_2d(ax) idx = 0 for (var_name, selection, x), ax_ in zip(plotters, (item for item in ax.flatten() if item is not None)): _plot_posterior_op(idx, x.flatten(), var_name, selection, ax=ax_, bw=bw, circular=circular, bins=bins, kind=kind, point_estimate=point_estimate, round_to=round_to, hdi_prob=hdi_prob, multimodal=multimodal, skipna=skipna, linewidth=linewidth, ref_val=ref_val, rope=rope, ax_labelsize=ax_labelsize, **kwargs) idx += 1 _title = Title() _title.text = make_label(var_name, selection) ax_.title = _title show_layout(ax, show) return ax
def plot_ious_bokeh(ious, zvalues): per_row = 50 dz = (ious.shape[1] - 1) // 2 ylabels = [z for z in range(-dz, dz + 1)] mapper = LinearColorMapper(palette=Plasma256, low=0.0, high=1.0) colorbar = ColorBar(color_mapper=mapper, major_label_text_font_size="5pt", label_standoff=12, location=(0, 0)) tabs = [] # one figure for every 200 sections newz = [] newiou = [] t = Title() t.text = "IOU Plot" xaxis = LinearAxis() yaxis = LinearAxis() for i in range(0, len(zvalues), 200): if i + 199 > len(zvalues): newz = zvalues[i:] newiou = ious[i:, :] else: newz = zvalues[i:i + 199] newiou = ious[i:i + 199, :] if len(newz) % per_row == 0: rows = len(newz) // per_row else: rows = (len(newz) // per_row) + 1 plots = [] if rows > 1: #p.add_layout(xaxis, 'below') #p.add_layout(yaxis, 'left') for r in range(rows): start = r * per_row xvalues = np.ndarray.flatten(newiou[start:start + per_row]) x_range1 = newz[start:start + per_row] #range(start, start+per_row+1) x_range = np.repeat(x_range1, len(ylabels)) y_range = np.tile(ylabels, len(x_range1)) source = ColumnDataSource( dict(x=x_range, y=y_range, iou=xvalues)) p = figure(title=t, plot_width=400 * rows, plot_height=100 * rows) p.axis.axis_line_color = None p.axis.major_tick_line_color = None p.axis.major_label_text_font_size = "10pt" p.axis.major_label_standoff = 0 #p.axis.major_label_orientation = 1.0 ''' glyph = Rect(x="x", y="y", width=1, height=1, fill_color={'field': 'iou', 'transform': mapper}, line_color=None) p.add_glyph(source, glyph) ''' p.rect(x="x", y="y", width=1, height=1, source=source, fill_color={ 'field': 'iou', 'transform': mapper }, line_color=None) plots.append(p) # tabs.append([p]) else: xvalues = np.ndarray.flatten(newiou) x_range = np.repeat(zvalues, len(ylabels)) y_range = [int(z) for z in ylabels] y_range = np.tile(y_range, len(zvalues)) p = figure(title=t) source = ColumnDataSource(dict(x=x_range, y=y_range, iou=xvalues)) glyph = Rect(x="x", y="y", width=1, height=1, fill_color={ 'field': 'iou', 'transform': mapper }, line_color=None) p.add_glyph(source, glyph) ''' p = figure(title=t) source = ColumnDataSource(dict(x=x_range, y=y_range, iou=xvalues)) p.rect(x="x", y="y", width=1, height=1, source=source, fill_color={'field': 'iou', 'transform': mapper}, line_color=None) ''' p.add_layout(colorbar, 'right') #show(p) #tabs.append([p]) plots.append(p) tabs = [[p] for p in plots] grid = gridplot(tabs) return grid
life.name = 'life' population = population_df_size[year] population.name = 'population' new_df = pd.concat([fertility, life, population, region_name], axis=1) sources['_' + str(year)] = ColumnDataSource(new_df) dictionary_of_sources = dict( zip([x for x in years], ['_%s' % x for x in years])) js_source_array = str(dictionary_of_sources).replace("'", "") xdr = Range1d(1, 9) ydr = Range1d(20, 100) plot = Plot( x_range=xdr, y_range=ydr, title=Title(text=''), plot_width=800, plot_height=400, outline_line_color=None, toolbar_location=None, min_border=20, ) AXIS_FORMATS = dict( minor_tick_in=None, minor_tick_out=None, major_tick_in=None, major_label_text_font_size="10pt", major_label_text_font_style="normal", axis_label_text_font_size="10pt", axis_line_color='#AAAAAA',
def _plot_mcse( ax, plotters, length_plotters, rows, cols, figsize, errorbar, rug, data, probs, extra_kwargs, extra_methods, mean_mcse, sd_mcse, rug_kwargs, idata, rug_kind, _markersize, _linewidth, show, ): if ax is None: _, ax = _create_axes_grid(length_plotters, rows, cols, figsize=figsize, backend="bokeh") for (var_name, selection, x), ax_ in zip(plotters, np.ravel(ax)): if errorbar or rug: values = data[var_name].sel(**selection).values.flatten() if errorbar: quantile_values = _quantile(values, probs) ax_.dash(probs, quantile_values) ax_.multi_line( list(zip(probs, probs)), [(quant - err, quant + err) for quant, err in zip(quantile_values, x)], ) else: ax_.circle(probs, x) if extra_methods: mean_mcse_i = mean_mcse[var_name].sel(**selection).values.item() sd_mcse_i = sd_mcse[var_name].sel(**selection).values.item() hline_mean = Span( location=mean_mcse_i, dimension="width", line_color="black", line_width=extra_kwargs["linewidth"] * 2, line_alpha=extra_kwargs["alpha"], ) ax_.renderers.append(hline_mean) hline_sd = Span( location=sd_mcse_i, dimension="width", line_color="black", line_width=extra_kwargs["linewidth"], line_alpha=extra_kwargs["alpha"], ) ax_.renderers.append(hline_sd) if rug: if rug_kwargs is None: rug_kwargs = {} if not hasattr(idata, "sample_stats"): raise ValueError("InferenceData object must contain sample_stats for rug plot") if not hasattr(idata.sample_stats, rug_kind): raise ValueError("InferenceData does not contain {} data".format(rug_kind)) rug_kwargs.setdefault("space", 0.1) _rug_kwargs = {} _rug_kwargs.setdefault("size", 8) _rug_kwargs.setdefault("line_color", rug_kwargs.get("line_color", "black")) _rug_kwargs.setdefault("line_width", 1) _rug_kwargs.setdefault("line_alpha", 0.35) _rug_kwargs.setdefault("angle", np.pi / 2) mask = idata.sample_stats[rug_kind].values.flatten() values = rankdata(values)[mask] if errorbar: rug_x, rug_y = ( values / (len(mask) - 1), np.full_like( values, min( 0, min(quantile_values) - (max(quantile_values) - min(quantile_values)) * 0.05, ), ), ) hline = Span( location=min( 0, min(quantile_values) - (max(quantile_values) - min(quantile_values)) * 0.05, ), dimension="width", line_color="black", line_width=_linewidth, line_alpha=0.7, ) else: rug_x, rug_y = ( values / (len(mask) - 1), np.full_like(values, 0,), ) hline = Span( location=0, dimension="width", line_color="black", line_width=_linewidth, line_alpha=0.7, ) ax_.renderers.append(hline) glyph = Dash(x="rug_x", y="rug_y", **_rug_kwargs) cds_rug = ColumnDataSource({"rug_x": np.asarray(rug_x), "rug_y": np.asarray(rug_y)}) ax_.add_glyph(cds_rug, glyph) title = Title() title.text = make_label(var_name, selection) ax_.title = title ax_.xaxis.axis_label = "Quantile" ax_.yaxis.axis_label = ( r"Value $\pm$ MCSE for quantiles" if errorbar else "MCSE for quantiles" ) if not errorbar: ax_.y_range._property_values["start"] = -0.05 # pylint: disable=protected-access ax_.y_range._property_values["end"] = 1 # pylint: disable=protected-access if show: grid = gridplot([list(item) for item in ax], toolbar_location="above") bkp.show(grid) return ax
def plot_violin( ax, plotters, figsize, rows, cols, sharex, sharey, shade_kwargs, shade, rug, rug_kwargs, bw, textsize, circular, hdi_prob, quartiles, backend_kwargs, show, ): """Bokeh violin plot.""" if backend_kwargs is None: backend_kwargs = {} backend_kwargs = { **backend_kwarg_defaults(("dpi", "plot.bokeh.figure.dpi"),), **backend_kwargs, } (figsize, *_, linewidth, _) = _scale_fig_size(figsize, textsize, rows, cols) shade_kwargs = {} if shade_kwargs is None else shade_kwargs rug_kwargs = {} if rug_kwargs is None else rug_kwargs rug_kwargs.setdefault("fill_alpha", 0.1) rug_kwargs.setdefault("line_alpha", 0.1) if ax is None: _, ax = _create_axes_grid( len(plotters), rows, cols, sharex=sharex, sharey=sharey, figsize=figsize, squeeze=False, backend="bokeh", backend_kwargs=backend_kwargs, ) else: ax = np.atleast_2d(ax) for (var_name, selection, x), ax_ in zip( plotters, (item for item in ax.flatten() if item is not None) ): val = x.flatten() if val[0].dtype.kind == "i": dens = cat_hist(val, rug, shade, ax_, **shade_kwargs) else: dens = _violinplot(val, rug, shade, bw, circular, ax_, **shade_kwargs) if rug: rug_x = -np.abs(np.random.normal(scale=max(dens) / 3.5, size=len(val))) ax_.scatter(rug_x, val, **rug_kwargs) per = np.percentile(val, [25, 75, 50]) hdi_probs = hdi(val, hdi_prob, multimodal=False) if quartiles: ax_.line( [0, 0], per[:2], line_width=linewidth * 3, line_color="black", line_cap="round" ) ax_.line([0, 0], hdi_probs, line_width=linewidth, line_color="black", line_cap="round") ax_.circle( 0, per[-1], line_color="white", fill_color="white", size=linewidth * 1.5, line_width=linewidth, ) _title = Title() _title.text = make_label(var_name, selection) ax_.title = _title ax_.xaxis.major_tick_line_color = None ax_.xaxis.minor_tick_line_color = None ax_.xaxis.major_label_text_font_size = "0pt" show_layout(ax, show) return ax
def _d_helper( vec, vname, color, bw, line_width, markersize, credible_interval, point_estimate, hpd_markers, outline, shade, ax, ): extra = dict() plotted = [] if vec.dtype.kind == "f": if credible_interval != 1: hpd_ = hpd(vec, credible_interval, multimodal=False) new_vec = vec[(vec >= hpd_[0]) & (vec <= hpd_[1])] else: new_vec = vec density, xmin, xmax = _fast_kde(new_vec, bw=bw) density *= credible_interval x = np.linspace(xmin, xmax, len(density)) ymin = density[0] ymax = density[-1] if outline: plotted.append( ax.line(x, density, line_color=color, line_width=line_width, **extra)) plotted.append( ax.line( [xmin, xmin], [-ymin / 100, ymin], line_color=color, line_dash="solid", line_width=line_width, muted_color=color, muted_alpha=0.2, )) plotted.append( ax.line( [xmax, xmax], [-ymax / 100, ymax], line_color=color, line_dash="solid", line_width=line_width, muted_color=color, muted_alpha=0.2, )) if shade: plotted.append( ax.patch(np.r_[x[::-1], x, x[-1:]], np.r_[np.zeros_like(x), density, [0]], fill_color=color, fill_alpha=shade, muted_color=color, muted_alpha=0.2, **extra)) else: xmin, xmax = hpd(vec, credible_interval, multimodal=False) bins = get_bins(vec) _, hist, edges = histogram(vec, bins=bins) if outline: plotted.append( ax.quad(top=hist, bottom=0, left=edges[:-1], right=edges[1:], line_color=color, fill_color=None, muted_color=color, muted_alpha=0.2, **extra)) else: plotted.append( ax.quad(top=hist, bottom=0, left=edges[:-1], right=edges[1:], line_color=color, fill_color=color, fill_alpha=shade, muted_color=color, muted_alpha=0.2, **extra)) if hpd_markers: plotted.append( ax.diamond(xmin, 0, line_color="black", fill_color=color, size=markersize)) plotted.append( ax.diamond(xmax, 0, line_color="black", fill_color=color, size=markersize)) if point_estimate is not None: est = calculate_point_estimate(point_estimate, vec, bw) plotted.append( ax.circle(est, 0, fill_color=color, line_color="black", size=markersize)) _title = Title() _title.text = vname ax.title = _title ax.title.text_font_size = "13pt" return plotted
def plot_rank( axes, length_plotters, rows, cols, figsize, plotters, bins, kind, colors, ref_line, labels, backend_kwargs, show, ): """Bokeh rank plot.""" if backend_kwargs is None: backend_kwargs = {} backend_kwargs = { **backend_kwarg_defaults(("dpi", "plot.bokeh.figure.dpi"), ), **backend_kwargs, } figsize, *_ = _scale_fig_size(figsize, None, rows=rows, cols=cols) if axes is None: _, axes = _create_axes_grid( length_plotters, rows, cols, figsize=figsize, squeeze=False, sharex=True, sharey=True, backend="bokeh", backend_kwargs=backend_kwargs, ) else: axes = np.atleast_2d(axes) for ax, (var_name, selection, var_data) in zip( (item for item in axes.flatten() if item is not None), plotters): ranks = scipy.stats.rankdata(var_data).reshape(var_data.shape) bin_ary = np.histogram_bin_edges(ranks, bins=bins, range=(0, ranks.size)) all_counts = np.empty((len(ranks), len(bin_ary) - 1)) for idx, row in enumerate(ranks): _, all_counts[idx], _ = histogram(row, bins=bin_ary) counts_normalizer = all_counts.max() / 0.95 gap = 1 width = bin_ary[1] - bin_ary[0] # Center the bins bin_ary = (bin_ary[1:] + bin_ary[:-1]) / 2 y_ticks = [] if kind == "bars": for idx, counts in enumerate(all_counts): counts = counts / counts_normalizer y_ticks.append(idx * gap) ax.vbar( x=bin_ary, top=y_ticks[-1] + counts, bottom=y_ticks[-1], width=width, fill_color=colors[idx], line_color="white", ) if ref_line: hline = Span(location=y_ticks[-1] + counts.mean(), line_dash="dashed", line_color="black") ax.add_layout(hline) if labels: ax.yaxis.axis_label = "Chain" elif kind == "vlines": ymin = np.full(len(all_counts), all_counts.mean()) for idx, counts in enumerate(all_counts): ax.circle(bin_ary, counts, fill_color=colors[idx], line_color=colors[idx]) x_locations = [(bin, bin) for bin in bin_ary] y_locations = [(ymin[idx], counts_) for counts_ in counts] ax.multi_line( x_locations, y_locations, line_dash="solid", line_color=colors[idx], line_width=3, ) if ref_line: hline = Span(location=all_counts.mean(), line_dash="dashed", line_color="black") ax.add_layout(hline) if labels: ax.xaxis.axis_label = "Rank (all chains)" ax.yaxis.ticker = FixedTicker(ticks=y_ticks) ax.xaxis.major_label_overrides = dict( zip(map(str, y_ticks), map(str, range(len(y_ticks))))) else: ax.yaxis.major_tick_line_color = None ax.yaxis.minor_tick_line_color = None ax.xaxis.major_label_text_font_size = "0pt" ax.yaxis.major_label_text_font_size = "0pt" _title = Title() _title.text = make_label(var_name, selection) ax.title = _title show_layout(axes, show) return axes
def _plot_ess( ax, plotters, xdata, ess_tail_dataset, mean_ess, sd_ess, idata, data, text_x, text_va, kind, extra_methods, rows, cols, figsize, kwargs, extra_kwargs, text_kwargs, _linewidth, _markersize, n_samples, relative, min_ess, xt_labelsize, titlesize, ax_labelsize, ylabel, rug, rug_kind, rug_kwargs, hline_kwargs, show, ): if ax is None: _, ax = _create_axes_grid( len(plotters), rows, cols, figsize=figsize, squeeze=False, constrained_layout=True, backend="bokeh", ) for (var_name, selection, x), ax_ in zip(plotters, np.ravel(ax)): ax_.circle(np.asarray(xdata), np.asarray(x), size=6) if kind == "evolution": ax_.line(np.asarray(xdata), np.asarray(x), legend_label="bulk") ess_tail = ess_tail_dataset[var_name].sel(**selection) ax_.line(np.asarray(xdata), np.asarray(ess_tail), color="orange", legend_label="tail") ax_.circle(np.asarray(xdata), np.asarray(ess_tail), size=6, color="orange") elif rug: if rug_kwargs is None: rug_kwargs = {} if not hasattr(idata, "sample_stats"): raise ValueError( "InferenceData object must contain sample_stats for rug plot" ) if not hasattr(idata.sample_stats, rug_kind): raise ValueError( "InferenceData does not contain {} data".format(rug_kind)) rug_kwargs.setdefault("space", 0.1) _rug_kwargs = {} _rug_kwargs.setdefault("size", 8) _rug_kwargs.setdefault("line_color", rug_kwargs.get("line_color", "black")) _rug_kwargs.setdefault("line_width", 1) _rug_kwargs.setdefault("line_alpha", 0.35) _rug_kwargs.setdefault("angle", np.pi / 2) values = data[var_name].sel(**selection).values.flatten() mask = idata.sample_stats[rug_kind].values.flatten() values = rankdata(values)[mask] rug_space = np.max(x) * rug_kwargs.pop("space") rug_x, rug_y = values / (len(mask) - 1), np.zeros_like(values) - rug_space glyph = Dash(x="rug_x", y="rug_y", **_rug_kwargs) cds_rug = ColumnDataSource({ "rug_x": np.asarray(rug_x), "rug_y": np.asarray(rug_y) }) ax_.add_glyph(cds_rug, glyph) hline = Span( location=0, dimension="width", line_color="black", line_width=_linewidth, line_alpha=0.7, ) ax_.renderers.append(hline) if extra_methods: mean_ess_i = mean_ess[var_name].sel(**selection).values.item() sd_ess_i = sd_ess[var_name].sel(**selection).values.item() hline = Span( location=mean_ess_i, dimension="width", line_color="black", line_width=2, line_dash="dashed", line_alpha=1.0, ) ax_.renderers.append(hline) hline = Span( location=sd_ess_i, dimension="width", line_color="black", line_width=1, line_dash="dashed", line_alpha=1.0, ) ax_.renderers.append(hline) hline = Span( location=400 / n_samples if relative else min_ess, dimension="width", line_color="red", line_width=3, line_dash="dashed", line_alpha=1.0, ) ax_.renderers.append(hline) title = Title() title.text = make_label(var_name, selection) ax_.title = title ax_.xaxis.axis_label = "Total number of draws" if kind == "evolution" else "Quantile" ax_.yaxis.axis_label = ylabel.format( "Relative ESS" if relative else "ESS") if show: grid = gridplot([list(item) for item in ax], toolbar_location="above") bkp.show(grid) return ax
def plot_autocorr( axes, plotters, max_lag, figsize, rows, cols, combined, textsize, backend_config, backend_kwargs, show, ): """Bokeh autocorrelation plot.""" if backend_config is None: backend_config = {} len_y = plotters[0][2].size backend_config.setdefault("bounds_x_range", (0, len_y)) backend_config = { **backend_kwarg_defaults(("bounds_y_range", "plot.bokeh.bounds_y_range"),), **backend_config, } if backend_kwargs is None: backend_kwargs = {} backend_kwargs = { **backend_kwarg_defaults(("dpi", "plot.bokeh.figure.dpi"),), **backend_kwargs, } figsize, _, _, _, line_width, _ = _scale_fig_size(figsize, textsize, rows, cols) if axes is None: axes = create_axes_grid( len(plotters), rows, cols, figsize=figsize, sharex=True, sharey=True, backend_kwargs=backend_kwargs, ) else: axes = np.atleast_2d(axes) data_range_x = DataRange1d( start=0, end=max_lag, bounds=backend_config["bounds_x_range"], min_interval=5 ) data_range_y = DataRange1d( start=-1, end=1, bounds=backend_config["bounds_y_range"], min_interval=0.1 ) for (var_name, selection, x), ax in zip( plotters, (item for item in axes.flatten() if item is not None) ): x_prime = x if combined: x_prime = x.flatten() y = autocorr(x_prime) ax.segment( x0=np.arange(len(y)), y0=0, x1=np.arange(len(y)), y1=y, line_width=line_width, line_color="black", ) ax.line([0, 0], [0, max_lag], line_color="steelblue") title = Title() title.text = make_label(var_name, selection) ax.title = title ax.x_range = data_range_x ax.y_range = data_range_y show_layout(axes, show) return axes
def plot(): from pandas_datareader import data import datetime from bokeh.models.annotations import Title from bokeh.plotting import figure, show, output_file from bokeh.embed import components from bokeh.resources import CDN start = datetime.datetime(2019, 8, 16) end = datetime.datetime(2020, 1, 16) df = data.DataReader(name="AAPL", data_source="yahoo", start=start, end=end) def increase_or_decrease(close, open): if close > open: value = "Increase" elif close < open: value = "Decrease" else: value = "Equal" return value df["Status"] = [ increase_or_decrease(close, open) for close, open in zip(df.Close, df.Open) ] df["Middle"] = (df.Open + df.Close) / 2 df["Height"] = abs(df.Close - df.Open) p = figure(x_axis_type='datetime', width=1000, height=300, sizing_mode='scale_width') title = Title() title.text = "Candlestick Chart" p.title = title p.grid.grid_line_alpha = 0.3 hours_12 = 12 * 60 * 60 * 1000 p.segment(df.index, df.Low, df.index, df.High, color="Black") p.rect(df.index[df.Status == "Increase"], df.Middle[df.Status == "Increase"], hours_12, df.Height[df.Status == "Increase"], fill_color="#27AF39", line_color="black") p.rect(df.index[df.Status == "Decrease"], df.Middle[df.Status == "Decrease"], hours_12, df.Height[df.Status == "Decrease"], fill_color="#DB1D1D", line_color="black") script1, div1 = components(p) cdn_js = CDN.js_files return render_template("plot.html", script1=script1, div1=div1, cdn_js=cdn_js[0])
p2.yaxis.axis_label = 'Ось 2' p2.xaxis.axis_label = 'временная ось 2' # p2.yaxis.axis_label = 'Скорость' # p2.xaxis.axis_label = 'время формирования точки на БВ' legend1 = Legend(items=[ ('Параметр 1', [aline]), ('Параметр 2', [bline]), ], location=(0, 250)) legend2 = Legend(items=[ ('Параметр 3', [cline]), ('Параметр 4', [dline]), ], location=(0, 250)) t1 = Title() t1.text = 'BOKEH_EXAMPLE_1_EMOTIONS' p1.title = t1 t2 = Title() t2.text = 'BOKEH_EXAMPLE_2_EMOTIONS' p2.title = t2 # p2.title = t p1.add_layout(legend1, 'left') p2.add_layout(legend2, 'left') # p2.add_layout(legend, 'left') checkboxes1 = CheckboxGroup(labels=list(['Параметр 1', 'Параметр 2']), active=[0, 1]) checkboxes2 = CheckboxGroup(labels=list(['Параметр 3', 'Параметр 4']), active=[0, 1])
def render_crossfilter(itmdt: Intermediate, plot_width: int, plot_height: int) -> column: """ Render crossfilter scatter plot with a regression line. """ # pylint: disable=too-many-locals, too-many-function-args df = itmdt["data"] df["__x__"] = df[df.columns[0]] df["__y__"] = df[df.columns[0]] source_scatter = ColumnDataSource(df) source_xy_value = ColumnDataSource({"x": [df.columns[0]], "y": [df.columns[0]]}) var_list = list(df.columns[:-2]) xcol = source_xy_value.data["x"][0] ycol = source_xy_value.data["y"][0] tooltips = [("X-Axis: ", "@__x__"), ("Y-Axis: ", "@__y__")] fig = Figure( plot_width=plot_width, plot_height=plot_height, toolbar_location=None, title=Title(text="Scatter Plot", align="center"), tools=[], x_axis_label=xcol, y_axis_label=ycol, ) scatter = fig.scatter("__x__", "__y__", source=source_scatter) hover = HoverTool(tooltips=tooltips, renderers=[scatter]) fig.add_tools(hover) x_select = Select(title="X-Axis", value=xcol, options=var_list, width=150) y_select = Select(title="Y-Axis", value=ycol, options=var_list, width=150) x_select.js_on_change( "value", CustomJS( args=dict( scatter=source_scatter, xy_value=source_xy_value, x_axis=fig.xaxis[0], ), code=""" let currentSelect = this.value; let xyValueData = xy_value.data; let scatterData = scatter.data; xyValueData['x'][0] = currentSelect; scatterData['__x__'] = scatterData[currentSelect]; x_axis.axis_label = currentSelect; scatter.change.emit(); xy_value.change.emit(); """, ), ) y_select.js_on_change( "value", CustomJS( args=dict( scatter=source_scatter, xy_value=source_xy_value, y_axis=fig.yaxis[0], ), code=""" let currentSelect = this.value; let xyValueData = xy_value.data; let scatterData = scatter.data; xyValueData['y'][0] = currentSelect; scatterData['__y__'] = scatterData[currentSelect]; y_axis.axis_label = currentSelect; scatter.change.emit(); xy_value.change.emit(); """, ), ) fig = column(row(x_select, y_select, align="center"), fig, sizing_mode="stretch_width") return fig