def plot_event_occurrence(city, topic, years=[]):
df = _load_city_topic(city, topic)
df = df.loc[df.year.isin(years), ['local_time', 'weekday']]
data = dict(day=df['weekday'].map(weekday_mapping),
time=df['local_time'].dt.hour +
df['local_time'].dt.minute / 60)
source = ColumnDataSource(data)
p = figure(plot_width=600, plot_height=300,
y_range=list(reversed(DAYS)), x_range=[6, 24],
title=f'{city} | {topic}')
p.circle(x=jitter('time', width=1),
y=jitter('day', width=0.6, range=p.y_range),
source=source, alpha=0.1)
hline = Span(location=2, dimension='width', line_width=0.5,
line_color='gray')
p.renderers.extend([hline])
p.ygrid.grid_line_color = None
p.yaxis.major_tick_line_color = None
p.xaxis.ticker = list(TIME.keys())
p.xaxis.major_label_overrides = TIME
p.xaxis.axis_label = 'Hour'
p.yaxis.axis_label = 'Day'
return p
def get_data(self, element, ranges, style):
dims = element.dimensions(label=True)
xidx, yidx = (1, 0) if self.invert_axes else (0, 1)
mapping = dict(x=dims[xidx], y=dims[yidx])
data = {}
if not self.static_source or self.batched:
xdim, ydim = dims[xidx], dims[yidx]
data[xdim] = element.dimension_values(xidx)
data[ydim] = element.dimension_values(yidx)
self._categorize_data(data, (xdim, ydim), element.dimensions())
cdata, cmapping = self._get_color_data(element, ranges, style)
data.update(cdata)
mapping.update(cmapping)
sdata, smapping = self._get_size_data(element, ranges, style)
data.update(sdata)
mapping.update(smapping)
if 'angle' in style and isinstance(style['angle'], (int, float)):
style['angle'] = np.deg2rad(style['angle'])
if self.jitter:
if self.invert_axes:
mapping['y'] = jitter(dims[yidx], self.jitter,
range=self.handles['y_range'])
else:
mapping['x'] = jitter(dims[xidx], self.jitter,
range=self.handles['x_range'])
self._get_hover_data(data, element)
return data, mapping, style
def get_data(self, element, ranges, style):
dims = element.dimensions(label=True)
xidx, yidx = (1, 0) if self.invert_axes else (0, 1)
mapping = dict(x=dims[xidx], y=dims[yidx])
data = {}
if not self.static_source or self.batched:
xdim, ydim = dims[xidx], dims[yidx]
data[xdim] = element.dimension_values(xidx)
data[ydim] = element.dimension_values(yidx)
self._categorize_data(data, (xdim, ydim), element.dimensions())
cdata, cmapping = self._get_color_data(element, ranges, style)
data.update(cdata)
mapping.update(cmapping)
sdata, smapping = self._get_size_data(element, ranges, style)
data.update(sdata)
mapping.update(smapping)
if 'angle' in style and isinstance(style['angle'], (int, float)):
style['angle'] = np.deg2rad(style['angle'])
if self.jitter:
if self.invert_axes:
mapping['y'] = jitter(dims[yidx], self.jitter,
range=self.handles['y_range'])
else:
mapping['x'] = jitter(dims[xidx], self.jitter,
range=self.handles['x_range'])
self._get_hover_data(data, element)
return data, mapping, style
def get_song_placement_graph(band_json, band, size):
with open('data/song_position_dict.json') as f:
song_position_dict = load(f)
song_position_lists = song_position_dict[band]
placement_df, top_songs = get_song_placement_df(band_json, song_position_lists)
iqr_df, avg_iqr_placement = get_iqr_df(song_position_lists, top_songs)
#Create color coding for placement
years = placement_df['year'].values
mapper = linear_cmap(field_name='year', palette=RdYlBu11, low=min(years), high=max(years))
top_songs_w_av = ['Average IQR'] + top_songs[::-1]
source_place = ColumnDataSource(placement_df)
source_iqr = ColumnDataSource(iqr_df)
top10_placement = figure(y_range=top_songs_w_av, title=band, frame_width=int(400*size),
plot_width=int(700*size), tooltips=[('Date','@date'), ('Show Placement','@hover')],
sizing_mode='stretch_both', toolbar_location=None
)
top10_placement.circle(x='placement', y=jitter('song', width=0.4, range=top10_placement.y_range),
radius=0.01, fill_alpha=0.6, source=source_place, color=mapper
)
top10_placement.hbar(y='Songs', left='Q1', right='Q3', source = source_iqr,
height = 0.4, color = yellow, fill_alpha=0.5
)
color_bar = ColorBar(color_mapper=mapper['transform'], width=8, location=(0, 0))
top10_placement.add_layout(color_bar, 'right')
top10_placement.xaxis.ticker = [0, 0.5, 1]
top10_placement.xaxis.major_label_overrides = {0: 'Start of Show', 0.5: 'Middle of Show', 1: 'End of Show', }
top10_placement.circle(x=1,y=0)
top10_placement.xaxis.axis_label = 'Placement of Top 10 Most Played Songs'
return top10_placement, avg_iqr_placement
def swarmplot(x=None,
y=None,
data=None,
width=500,
height=500,
p=None,
hue_order=None,
jitter_width=0.6,
s=5,
alpha=0.5,
line_color='black',
**plot_kw):
if len(x) == 1:
data['x'] = data[x]
else:
data['x'] = list(data[x].itertuples(index=False, name=None))
if p is None:
p = figure(x_range=FactorRange(*data['x'].unique()),
width=width,
height=height,
min_border=100,
x_axis_label=x[0],
y_axis_label=y)
p.circle(x=jitter('x', width=jitter_width, range=p.x_range),
y=y,
line_color=line_color,
source=data,
size=s,
alpha=alpha,
**plot_kw)
return p
def analysis(request):
'''
Render analysis page
'''
feature_name = request.GET.get('feature')
feature_names = ["beds", "baths"]
if feature_name == "baths":
cats = list(set(House.objects.values_list('baths', flat=True)))
else:
feature_name = "beds"
cats = list(set(House.objects.values_list('beds', flat=True)))
rent = list(House.objects.values_list('rent', flat=True))
g = list(House.objects.values_list(feature_name, flat=True))
data = {'rent': rent, 'category': g}
source = ColumnDataSource(data=data)
cats = sorted(cats)
p = figure(plot_width=800,
plot_height=800,
y_range=cats,
title="Rent by Category")
p.circle(x='rent',
y=jitter('category', width=0.6, range=p.y_range),
alpha=0.3,
source=source)
p.x_range.range_padding = 0
p.ygrid.grid_line_color = None
script, div = components(p)
return render(
request, "analysis.html", {
'script': script,
'div': div,
'feature_names': feature_names,
"current_feature_name": feature_name
})
def boxplot_single(info, cmap, col1, col2=None, scatter_data=None):
info['IQR'] = info.q3 - info.q1
info['upper'] = np.min([info['max'], info.q3 + 1.5 * info.IQR], axis=0)
info['lower'] = np.max([info['min'], info.q1 - 1.5 * info.IQR], axis=0)
info['color'] = [cmap[f] for f in info[col1]]
tooltips = []
if scatter_data is not None:
tooltips = scatter_data.drop(['y', col1], axis=1).columns
tooltips = zip(tooltips, '@' + tooltips)
p = figure(title=f"{col2} vs {col1}",
background_fill_color="#efefef",
plot_width=300,
plot_height=400,
tooltips=list(tooltips),
x_range=info[col1].tolist())
# stems
p.segment(col1, 'upper', col1, 'q3', line_color="black", source=info)
p.segment(col1, 'lower', col1, 'q1', line_color="black", source=info)
# boxes
p.vbar(x=col1,
width=0.7,
bottom='q2',
top='q3',
line_color="black",
color='color',
source=info)
p.vbar(x=col1,
width=0.7,
bottom='q1',
top='q2',
line_color="black",
color='color',
source=info)
if scatter_data is not None:
scatter_data = scatter_data.sample(frac=1).groupby(col1).head(500)
scatter_data['color'] = [cmap[x] for x in scatter_data[col1]]
p.circle(x=jitter(col1, 0.2, range=p.x_range),
y='y',
line_color='black',
fill_color='color',
alpha=0.5,
source=scatter_data)
# # whiskers (almost-0 height rects simpler than segments)
# h = np.abs(info.q3).mean()
# p.rect(x=col1, y='lower', width=0.2, height=0.01*h, color="black", source=info)
# p.rect(x=col1, y='upper', width=0.2, height=0.01*h, color="black", source=info)
p.xaxis.major_label_orientation = "vertical"
return p
def create(self):
"add to doc"
self._src = {i: ColumnDataSource(data = j) for i, j in self._data(None).items()}
self._fig = self.figure(y_range = Range1d, x_range = FactorRange())
self._fig.grid[0].grid_line_alpha = self._theme.xgridalpha
self._ref = LinearAxis(axis_label = self._theme.reflabel,
formatter = NumeralTickFormatter(format = "0"))
self._fig.add_layout(self._ref, 'right')
jtr = jitter("bead", range = self._fig.x_range, width = .75)
self.addtofig(self._fig, "events", x = jtr, y = 'bases',
source = self._src["events"])
self.addtofig(self._fig, "hpin", x = "bead", y = 'bases', source = self._src["hpin"])
rend = self.addtofig(self._fig, "peaks", x = "bead", y = 'bases',
source = self._src["peaks"])
hover = self._fig.select(HoverTool)
if len(hover) > 0:
hover = hover[0]
hover.update(point_policy = self._theme.tooltippolicy,
tooltips = self._theme.tooltips,
mode = self._theme.tooltipmode,
renderers = [rend])
self.linkmodeltoaxes(self._fig)
self._fig.yaxis.formatter = NumeralTickFormatter(format = self._theme.format)
self._errors = PlotError(self._fig, self._theme)
return self._fig
def get_data(self, element, ranges, style):
dims = element.dimensions(label=True)
xidx, yidx = (1, 0) if self.invert_axes else (0, 1)
mapping = dict(x=dims[xidx], y=dims[yidx])
data = {}
if not self.static_source:
xdim, ydim = dims[xidx], dims[yidx]
data[xdim] = element.dimension_values(xidx)
data[ydim] = element.dimension_values(yidx)
self._categorize_data(data, (xdim, ydim), element.dimensions())
cdata, cmapping = self._get_color_data(element, ranges, style)
data.update(cdata)
mapping.update(cmapping)
sdata, smapping = self._get_size_data(element, ranges, style)
data.update(sdata)
mapping.update(smapping)
if self.jitter:
axrange = 'y_range' if self.invert_axes else 'x_range'
mapping['x'] = jitter(dims[xidx],
self.jitter,
range=self.handles[axrange])
self._get_hover_data(data, element)
return data, mapping, style
def plottingAllData(df, means, labels, indexes, param, colors):
"""
Plots the data included in the dataframe "df" from liquid and solid grown cells
"""
p = bokeh.plotting.figure(width=600,
height=600,
y_range=labels,
x_axis_type='linear',
x_axis_label='Fluorescence intensity',
title="Motor " + param +
" on solid vs liquid environement")
for i, index in enumerate(indexes):
p.circle(
source=df.loc[index, :],
x=param,
y=jitter('Labels', width=0.3, range=p.y_range),
color=colors[i],
alpha=0.3,
#legend = labelsAll[i]
)
p.circle(source=means,
x=param,
y='Labels',
size=10,
line_color='black',
fill_color='white',
legend="medians")
p.add_tools(
HoverTool(tooltips=[('Strain', '@{Strain}'),
('Growth condition', '@{Growth}'),
(param, '@{' + param + '}'),
('Biological replicate', '@{Bio_Rep}')], ))
return p
def plot_accidents_by_time_each_day(self, data, output_filename):
output_path = "{}/{}.html".format(self.output_directory, output_filename)
output_file(output_path)
days_english = np.array(["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"])
p = figure(
y_range=days_english.tolist(),
x_axis_type="datetime",
x_axis_label="time",
toolbar_location=None,
sizing_mode="stretch_both",
aspect_ratio=self.aspect_ratio,
tools="",
)
p.circle(
x="DATA_HORA",
y=jitter("DAY_ENGLISH", width=0.4, range=p.y_range),
source=data,
alpha=0.2,
)
p.xaxis[0].formatter.days = ["%Hh"]
p.x_range.range_padding = 0
p.ygrid.grid_line_color = None
self.plots[output_filename] = p
save(p)
def freqinpoem(poem_code, tokens):
if tokens is None:
tokens = ["אַ".decode('utf8')]
words_v = tokens
text = words(poems[poem_code][5])
title = poems[poem_code][1]
# make connection, format query
cnx = mysql.connector.connect(**config)
cursor = cnx.cursor()
query = "SELECT name_y FROM poet WHERE name_e=\"" + poems[poem_code][
3] + "\""
cursor.execute(query)
db_poet = cursor.fetchall()
cnx.close()
poet = db_poet[0][0]
x = []
y = []
con = []
for x_pos in range(len(text)):
for y_pos in range(len(words_v)):
if text[x_pos] == words_v[y_pos]:
x.append(x_pos)
y.append(words_v[y_pos])
line = "..."
for w in text[x_pos - 3:x_pos + 4]:
line += w + " "
line += "..."
con.append(line)
hover = HoverTool(tooltips=[("Offset", "@x" + "/" +
str(len(text))), ("Word",
"@y"), ("Context", "@con")])
data = dict(x=x, y=y, con=con)
src = ColumnDataSource(data)
p = figure(plot_height=400,
y_range=words_v,
title="Dispersion for :" + title + " פֿון ".decode('utf8') +
poet,
tools="pan,wheel_zoom,box_zoom,save,reset",
active_scroll="wheel_zoom")
p.add_tools(hover)
p.xaxis.axis_label = "Word Offset"
p.yaxis.axis_label = "Search Word"
p.x_range.range_padding = 0
p.ygrid.grid_line_color = None
p.circle(x='x',
y=jitter('y', width=0.6, range=p.y_range),
source=src,
alpha=0.6,
size=6,
fill_color=Set2[8][0])
return p
def test_basic(self) -> None:
t = bt.jitter("foo", width=0.5, mean=0.1, distribution="normal")
assert isinstance(t, Field)
assert t.field == "foo"
assert isinstance(t.transform, Jitter)
assert t.transform.width == 0.5
assert t.transform.mean == 0.1
assert t.transform.distribution == "normal"
assert t.transform.range is None
def test_defaults(self) -> None:
t = bt.jitter("foo", width=0.5)
assert isinstance(t, Field)
assert t.field == "foo"
assert isinstance(t.transform, Jitter)
assert t.transform.width == 0.5
assert t.transform.mean == 0
assert t.transform.distribution == "uniform"
assert t.transform.range is None
def test_basic(self):
t = bt.jitter("foo", width=0.5, mean=0.1, distribution="normal")
assert isinstance(t, dict)
assert set(t) == {"field", "transform"}
assert t['field'] == "foo"
assert isinstance(t['transform'], Jitter)
assert t['transform'].width == 0.5
assert t['transform'].mean == 0.1
assert t['transform'].distribution == "normal"
assert t['transform'].range is None
def test_defaults(self):
t = bt.jitter("foo", width=0.5)
assert isinstance(t, dict)
assert set(t) == {"field", "transform"}
assert t['field'] == "foo"
assert isinstance(t['transform'], Jitter)
assert t['transform'].width == 0.5
assert t['transform'].mean == 0
assert t['transform'].distribution == "uniform"
assert t['transform'].range is None
def test_basic(self):
t = bt.jitter("foo", width=0.5, mean=0.1, distribution="normal")
assert isinstance(t, dict)
assert set(t) == {"field", "transform"}
assert t['field'] == "foo"
assert isinstance(t['transform'], Jitter)
assert t['transform'].width == 0.5
assert t['transform'].mean == 0.1
assert t['transform'].distribution == "normal"
assert t['transform'].range is None
def test_defaults(self):
t = bt.jitter("foo", width=0.5)
assert isinstance(t, dict)
assert set(t) == {"field", "transform"}
assert t['field'] == "foo"
assert isinstance(t['transform'], Jitter)
assert t['transform'].width == 0.5
assert t['transform'].mean == 0
assert t['transform'].distribution == "uniform"
assert t['transform'].range is None
def prepare_plots3(target_vals,epoch, METRICSPATH):
cfm_file = f"{METRICSPATH}/confusion-{epoch}.png"
bok_file = f"{METRICSPATH}/ranking_{epoch}.html"
classes, rankings, preds, pred_rank = [],[],[],[]
for t_ in target_vals:
cl_,ra_,pr_,em_ = t_
classes.append(cl_)
rankings.append(ra_)
preds.append(pr_)
pred_rank.append(em_)
classes = np.squeeze(np.concatenate(classes))
rankings = np.squeeze(np.concatenate(rankings))
predictions = np.concatenate([softmax(p,axis=0) for p in preds])
pred_rank = np.concatenate(pred_rank)
activations = np.argmax(predictions,axis=1)
conf_mat = confusion_matrix(classes,activations)
fig = plt.figure(figsize=[10,8])
plot_confusion_matrix(conf_mat, classes=class_names, normalize=False,
title=f'Confusion matrix epoch {epoch}')
plt.savefig(cfm_file,format="png")
pil_image = fig2pil(fig)
neptune.send_image('conf_mat', pil_image)
df = pd.DataFrame(data={ 'tar': rankings, 'pred': pred_rank, 'class': classes})
palette = magma(num_of_classes + 1)
p = figure(plot_width=600, plot_height=800, title=f"Ranking by exercise, epoch {epoch}")
p.xgrid.grid_line_color = None
p.xaxis.axis_label = 'Target ranking'
p.yaxis.axis_label = 'Predicted ranking'
for cl in range(num_of_classes):
if cl == 6:
continue
df2 = df.loc[df['class']==cl]
p.circle(x=jitter('tar',0.3), y='pred', size=8, alpha=0.1, color=palette[cl], legend=class_names[cl], source=df2 )
p.line(x='tar', y='pred', line_width=2, alpha=0.5, color=palette[cl],legend=class_names[cl], source=df2.groupby(by="tar").mean())
p.legend.location = "top_left"
p.legend.click_policy="hide"
output_file(bok_file, title="Ranking by exercise")
save(p)
pil_image2 = get_screenshot_as_png(p)
neptune.send_image('rank_distances', pil_image2)
def test_with_range(self) -> None:
r = FactorRange("a")
t = bt.jitter("foo", width=0.5, mean=0.1, range=r)
assert isinstance(t, Field)
assert t.field == "foo"
assert isinstance(t.transform, Jitter)
assert t.transform.width == 0.5
assert t.transform.mean == 0.1
assert t.transform.distribution == "uniform"
assert t.transform.range is r
assert t.transform.range.factors == ["a"]
def test_with_range(self):
r = FactorRange("a")
t = bt.jitter("foo", width=0.5, mean=0.1, range=r)
assert isinstance(t, dict)
assert set(t) == {"field", "transform"}
assert t['field'] == "foo"
assert isinstance(t['transform'], Jitter)
assert t['transform'].width == 0.5
assert t['transform'].mean == 0.1
assert t['transform'].distribution == "uniform"
assert t['transform'].range is r
assert t['transform'].range.factors == ["a"]
def plot_jitter(data_frame):
ratings = sorted(data_frame.rating.unique())
jitter_plot = figure(plot_width=1600, plot_height=800,
title="Application Rating Vs No. of Installations", y_axis_type='log')
jitter_plot.xgrid.grid_line_color = None
jitter_plot.xaxis[0].ticker = ratings
jitter_plot.circle(x=jitter('rating', 0.4), y='installs', size=9, alpha=0.4, source=data_frame)
jitter_plot.xaxis.axis_label = 'Ratings'
jitter_plot.yaxis.axis_label = 'No. of Installations'
output_file("./Data/jitter.html")
show(jitter_plot)
return True
def test_with_range(self):
r = FactorRange("a")
t = bt.jitter("foo", width=0.5, mean=0.1, range=r)
assert isinstance(t, dict)
assert set(t) == {"field", "transform"}
assert t['field'] == "foo"
assert isinstance(t['transform'], Jitter)
assert t['transform'].width == 0.5
assert t['transform'].mean == 0.1
assert t['transform'].distribution == "uniform"
assert t['transform'].range is r
assert t['transform'].range.factors == ["a"]
def build_trade_scatter(path, product_id, output_file=None, show=False):
product_df = pd.read_csv(
path,
index_col=None,
parse_dates=['server_datetime', 'exchange_datetime'])
# Get the weekday and time
product_df['weekday_name'] = product_df[
'exchange_datetime'].dt.weekday_name
product_df['time'] = product_df['exchange_datetime'].dt.time
# Setting color based on buy/sell
color_map = {'sell': C_SELL, 'buy': C_BUY}
product_df['color'] = [color_map[entry] for entry in product_df['side']]
# Days reversed so they will be in order top to bottom
days = [
'Sunday', 'Saturday', 'Friday', 'Thursday', 'Wednesday', 'Tuesday',
'Monday'
]
source = ColumnDataSource(product_df)
tools = 'save,pan,box_zoom,xwheel_zoom,reset'
p = bplot.figure(title='Trades Over Time',
tools=tools,
plot_width=800,
plot_height=300,
y_range=days,
active_scroll='xwheel_zoom',
x_axis_type='datetime',
background_fill_color=C_CHART_BG)
p.circle(x='time',
y=jitter('weekday_name', width=0.6, range=p.y_range),
source=source,
alpha=0.6,
fill_color='color',
line_color=None)
p.xaxis[0].formatter.days = ['%Hh']
p.x_range.range_padding = 0
styles = {}
_apply_figure_styles(p, **styles)
if output_file:
bplot.output_file(output_file)
bplot.save(p)
if show:
bplot.show(p)
return p
def interactive_scatterplot(pdata,
tooltip_cols=[
"x", "y", "dataset", "category", "frequency"
]):
output_notebook()
p = figure(
title="comparison",
y_axis_type="log",
x_axis_type="log",
plot_width=800,
plot_height=500,
tools=[HoverTool(), PanTool(),
BoxZoomTool(),
ResetTool()],
tooltips=", ".join(["@{}".format(col) for col in tooltip_cols]),
# "@x, @y, @dataset, @category, @query_string, @frequency",
background_fill_color="#fafafa",
)
source = ColumnDataSource(pdata)
p.circle(
x=jitter("x", width=0.1),
y=jitter("y", width=0.1),
size=10,
fill_color=make_color_map(pdata, "dataset"),
line_color="black",
source=source,
)
def url_tool(url_column1, url_column2):
url = f"http://*****:*****@{url_column1}&other=@{url_column2}"
taptool = TapTool()
taptool.callback = OpenURL(url=url)
return taptool
p.add_tools(url_tool("session_path", "base_session_path"))
show(p)
def plot_jitter2(data_frame):
pricing = sorted(data_frame.price.unique())
jitter_plot = figure(plot_width=1600, plot_height=800,
title="Application Rating Vs Price of Applications", y_axis_type='log')
jitter_plot.xgrid.grid_line_color = "red"
jitter_plot.xaxis[0].ticker = pricing
jitter_plot.circle(x=jitter('price', 0.4), y='installs',
size=9, alpha=0.4, source=data_frame, color="red")
jitter_plot.xaxis.axis_label = 'price'
jitter_plot.yaxis.axis_label = 'No. of Installations'
output_file("./Data/jitter2.html")
show(jitter_plot)
return True
def plot_games(data, model, features, **plot_kwargs):
plot_kwargs.setdefault("x_axis_label", features[0])
plot_kwargs.setdefault("y_axis_label", features[1])
plot_kwargs.setdefault("tools", TOOLS)
plot_kwargs.setdefault(
"tooltips",
[
("name", "@name"),
("year", "@year"),
("complexity", "@complexity"),
("time", "@min_time–@max_time minutes"),
("age", "@min_age+"),
],
)
plot = figure(**plot_kwargs)
data["color"] = [
"#193F4A" if kennerspiel else "#E30613" for kennerspiel in data.ksdj
]
data["marker"] = np.where(
model.predict(data[features]) == data.ksdj, "circle", "square")
plot.scatter(
source=data,
x=features[0],
y=jitter(features[1], width=0.25, distribution="normal"),
color="color",
marker="marker",
# alpha=0.9,
size=8,
)
w1 = model.coef_[0, 0]
w2 = model.coef_[0, 1]
b = model.intercept_[0]
slope = Slope(
gradient=-w1 / w2,
y_intercept=-b / w2,
line_color="black",
line_dash="dashed",
line_width=2,
)
plot.add_layout(slope)
return plot
def get_timeline_plot(source, toolbox, names, y, title):
"Plot the observations through time accross given y"
p = figure(plot_width=1000,
plot_height=300,
y_range=names,
x_axis_type='datetime',
title=title,
tools=toolbox)
p.circle(x='date',
y=jitter(y, width=0.6, range=p.y_range),
source=source,
alpha=0.3,
line_color="colors_case",
fill_color="colors_case")
p.toolbar.active_scroll = p.select_one(WheelZoomTool)
return p
def update():
df = get_publish_table(y_axis.value)
p.y_range.factors = df[y_axis.value].dropna().unique().tolist()
p.circle(x='x',
y=jitter('y', width=0.2, range=p.y_range),
source=source,
alpha=0.3)
p.xaxis[0].formatter.days = ['%Hh']
p.x_range.range_padding = 0
p.ygrid.grid_line_color = None
p.xaxis.axis_label = x_axis.value
p.yaxis.axis_label = y_axis.value
p.title.text = "%d items selected" % len(df)
source.data = dict(
x=df[x_axis.value],
y=df[y_axis.value],
# headline=df['headline'],
)
def plot(self):
plot = figure(
title="Requests by Time of Day",
tools="",
toolbar_location=None,
sizing_mode="scale_width",
# plot_width=800,
plot_height=300,
y_range=list(reversed(DAYS)),
x_axis_type="datetime",
)
plot.circle(
x="time",
y=jitter("day", width=0.6, range=plot.y_range),
source=ColumnDataSource(self.data()),
alpha=0.3,
)
plot.xaxis.formatter.days = ["%Hh"]
plot.x_range.range_padding = 0
plot.ygrid.grid_line_color = None
return plot
def plot_read_hash_abundances(dfm: pd.DataFrame, ofname: Path) -> None:
"""Plot distribution of unique read counts.
:param dfm: pd.DataFrame containing one row per sample/hash combination
:param ofname: Path to output file for figure
"""
# Set data sources
dfm["read_hash"] = dfm["read_hash"].str.slice(0, 6)
source = ColumnDataSource(dfm)
categories = sorted(set(source.data["read_hash"]))
colours = factor_cmap("read_hash",
palette=Category20[len(categories)],
factors=categories)
# Render abundances
tooltips = [("sample", "@sample_name"), ("abundance", "@abundance")]
fig = figure(
x_range=categories,
plot_width=100 * len(categories),
plot_height=600,
title="Unique Read Abundances By Hash",
y_axis_type="log",
tooltips=tooltips,
)
fig.scatter(
x=jitter("read_hash", width=0.4, range=fig.x_range),
y="abundance",
source=source,
size=10,
alpha=0.6,
hover_fill_alpha=1,
fill_color=colours,
)
# Save figure
output_file(ofname)
save(fig)
def analysis(request):
feature_name = request.GET.get('feature')
feature_names = ["bedrooms", "bathrooms", "room_type_category"]
data_path = './new_york.json'
json_data = open(data_path)
data = json.loads(json_data.read())
prices = []
category = []
if not feature_name:
feature_name = 'bedrooms'
for element in data:
if element[feature_name] is not None:
prices.append(element['price'])
category.append(element[feature_name])
json_data.close()
data = {'prices': prices, 'category': category}
source = ColumnDataSource(data=data)
cats = list(set(category))
cats = [str(c) for c in sorted(cats)]
p = figure(plot_width=800,
plot_height=800,
y_range=cats,
title="Rent by Category")
p.circle(x='prices',
y=jitter('category', width=0.6, range=p.y_range),
alpha=0.3,
source=source)
p.x_range.range_padding = 0
p.ygrid.grid_line_color = None
script, div = components(p)
return render(
request, "analysis.html", {
'script': script,
'div': div,
'feature_names': feature_names,
"current_feature_name": feature_name
})
def box_plot(x,y,cl_ar,bok_file,epoch):
class_names = ['squat', 'deadlift', 'pushups', 'pullups', 'wallpushups', 'lunges', 'other', 'cleanandjerk']
num_of_classes = len(class_names)
df = pd.DataFrame(data={ 'tar': x, 'pred': y, 'class': cl_ar})
palette = magma(num_of_classes + 1)
p = figure(plot_width=600, plot_height=800, title=f"Ranking by exercise, epoch {epoch}")
p.xgrid.grid_line_color = None
p.xaxis.axis_label = 'Target ranking'
p.yaxis.axis_label = 'Predicted ranking'
for cl in range(num_of_classes):
if cl == 6:
continue
df2 = df.loc[df['class']==cl]
p.circle(x=jitter('tar', 0.5), y='pred', size=8, alpha=0.1, color=palette[cl], legend=class_names[cl], source=df2 )
p.line(x='tar', y='pred', line_width=2, alpha=0.5, color=palette[cl], source=df2.groupby(by="tar").mean())
p.legend.location = "top_left"
p.legend.click_policy="hide"
output_file(bok_file, title="Ranking by exercise")
save(p)
pil_image2 = get_screenshot_as_png(p)
neptune.send_image('rank_distances', pil_image2)
from bokeh.io import show, output_file
from bokeh.models import ColumnDataSource
from bokeh.plotting import figure
from bokeh.sampledata.commits import data
from bokeh.transform import jitter
output_file("bars.html")
DAYS = ['Sun', 'Sat', 'Fri', 'Thu', 'Wed', 'Tue', 'Mon']
source = ColumnDataSource(data)
p = figure(plot_width=800,
plot_height=300,
y_range=DAYS,
x_axis_type='datetime',
title="Commits by Time of Day (US/Central) 2012—2016")
p.circle(x='time',
y=jitter('day', width=0.6, range=p.y_range),
source=source,
alpha=0.3)
p.xaxis[0].formatter.days = ['%Hh']
p.x_range.range_padding = 0
p.ygrid.grid_line_color = None
show(p)
from bokeh.layouts import row
from bokeh.models import ColumnDataSource
from bokeh.plotting import figure, show, output_file
from bokeh.sampledata.autompg import autompg
from bokeh.transform import jitter
source = ColumnDataSource(autompg)
TOOLS = "save,box_select,lasso_select"
s1 = figure(tools=TOOLS, plot_width=400, plot_height=400,
x_axis_label='# Cylinders', y_axis_label='MPG')
s1.circle(jitter('cyl', 0.5), 'mpg', source=source)
s2 = figure(tools=TOOLS, plot_width=400, plot_height=400,
x_axis_label='Acceleration', y_axis_label='MPG')
# linked brushing is expressed by sharing data sources between renderers
s2.circle('accel', 'mpg', source=source)
output_file("linked_brushing.html", title="linked_brushing.py example")
show(row(s1,s2))
from bokeh.io import show, output_file
from bokeh.models import ColumnDataSource
from bokeh.plotting import figure
from bokeh.sampledata.commits import data
from bokeh.transform import jitter
output_file("bars.html")
DAYS = ['Sun', 'Sat', 'Fri', 'Thu', 'Wed', 'Tue', 'Mon']
source = ColumnDataSource(data)
p = figure(plot_width=800, plot_height=300, y_range=DAYS, x_axis_type='datetime',
title="Commits by Time of Day (US/Central) 2012—2016")
p.circle(x='time', y=jitter('day', width=0.6, range=p.y_range), source=source, alpha=0.3)
p.xaxis[0].formatter.days = ['%Hh']
p.x_range.range_padding = 0
p.ygrid.grid_line_color = None
show(p)
from bokeh.layouts import column
from bokeh.plotting import figure, show, output_file
from bokeh.sampledata.autompg import autompg
from bokeh.transform import jitter
years = sorted(autompg.yr.unique())
p1 = figure(plot_width=600, plot_height=300, title="Years vs mpg without jittering")
p1.xgrid.grid_line_color = None
p1.xaxis[0].ticker = years
p1.circle(x='yr', y='mpg', size=9, alpha=0.4, source=autompg)
p2 = figure(plot_width=600, plot_height=300, title="Years vs mpg with jittering")
p2.xgrid.grid_line_color = None
p2.xaxis[0].ticker = years
p2.circle(x=jitter('yr', 0.4), y='mpg', size=9, alpha=0.4, source=autompg)
output_file("jitter.html")
show(column(p1, p2))
