def create_barchart(self, group_df, group_name, substrate):
'''Calculates mean if all labels are equivalent'''
labels = ["Batch", "Wafer No.", "HM location", "Test structure"]
labels.remove(self.sort_parameter)
innermost_groups = group_df.groupby(labels)
r_mean = innermost_groups["Resistivity"].mean(
) ##calculate the error that happens here
'''creates chart data and BarChart Object'''
keys = ["/".join(key) for key in innermost_groups.groups.keys()]
chart_data = [(label, resistance)
for label, resistance in zip(keys, r_mean)]
labels = "/".join(labels)
chart = hv.Bars(chart_data, hv.Dimension(labels), "Resistivity")
'''calculates std_mean with error propagation'''
std_mean_l = []
for group in innermost_groups: #each group corresponds to a bar
std_mean2 = 0
for i in group[1]["Standard deviation"]:
std_mean2 += (i / len(group[1]["Standard deviation"]))**2
std_mean2 = np.sqrt(std_mean2)
std_mean_l.append(std_mean2)
'''calculate error of r_mean '''
r_mean_error = []
for index, group in enumerate(innermost_groups):
diff_from_mean = 0
group_mean = r_mean[index]
for i in group[1]["Resistivity"]:
if len(group[1]["Resistivity"]) > 1:
diff_from_mean += ((i - group_mean)**2 /
(len(group[1]["Resistivity"]) - 1))
diff_from_mean = np.sqrt(diff_from_mean)
r_mean_error.append(diff_from_mean)
error = [max(i, j) for i, j in zip(r_mean_error, std_mean_l)]
'''creates errorbars and configures the plot'''
error_bars = hv.ErrorBars((keys, r_mean, error))
error_bars.opts(line_width=5)
chart = chart * error_bars
chart.opts(title=substrate + " " + group_name,
**self.config["Van_der_Pauw"].get("General", {}),
ylim=(0, self.limits[substrate]),
xrotation=45)
if self.PlotDict["All"] is None:
self.PlotDict["All"] = chart
else:
self.PlotDict["All"] = self.PlotDict["All"] + chart
def plot_country_recovery_rates(country):
recovered_country = recovered.loc[:, (slice(None), country)].sum(axis=1)
recovered_country_rate = ((
(recovered_country / recovered_country.shift() - 1) * 100).replace(
[np.inf, -np.inf], np.nan).dropna())
return (hv.Bars([
(i, recovered_country_rate.loc[i])
for i in recovered_country_rate.index
]).redim(x='Date',
y='Percent').opts(height=400,
width=700,
fontsize={'xticks': 6},
xrotation=90,
ylim=(0, 100),
title='Day-over-Day Growth of Recovered Cases',
tools=[rhover],
show_frame=False))
def get_daily_increment(complete_df):
df = complete_df.copy()
df = df.groupby('Fecha').sum()[['Casos', 'Fallecidos']]
df.reset_index(inplace=True)
df.Fecha = df.loc[:, 'Fecha'].dt.strftime('%d-%m')
key_columns = ['Casos', 'Fallecidos']
colors = ['#cf3e3e', '#000000']
plots = []
for column, color in zip(key_columns, colors):
total = df[column].values
after = total[1:]
before = total[:-1]
increment = after - before
# over total
increment = np.append(0, increment)
total = np.where(total == 0, 1, total) # preventing divisions with 0
increment_per = (increment / total) * 100
df[f'Incremento porcentual en {column.lower()}'] = np.round(
increment_per, 2)
# # plot
bars = hv.Bars(df,
kdims=['Fecha'],
vdims=f'Incremento porcentual en {column.lower()}',
label=f'Incremento porcentual en {column.lower()}')
bars.opts(width=width,
height=height,
color=color,
xrotation=90,
invert_xaxis=False,
shared_axes=False,
tools=['hover'],
show_legend=True,
show_grid=True,
title='\nIncremento porcentual en {}'.format(column.lower()),
margin=(10, 0, 0, 0))
plots.append(bars)
layout = plots[0] + plots[1]
# layout.opts(tabs=True)
return layout
def plot_cpu_frequency_transitions(self,
cpu: CPU,
pct: bool = False,
domain_label: bool = False):
"""
Plot frequency transitions count of the specified CPU
:param cpu: The CPU to genererate the plot for
:type cpu: int
:param pct: Plot frequency transitions in percentage
:type pct: bool
:param domain_label: If ``True``, the labels will mention all CPUs in
the domain, rather than the CPU passed.
:type domain_label: bool
"""
df = self.df_cpu_frequency_transitions(cpu)
if pct:
df = df * 100 / df.sum()
ylabel = 'Transitions share (%)' if pct else 'Transition count'
if domain_label:
domains = self.trace.plat_info['freq-domains']
rev_domains = {
cpu: sorted(domain)
for domain in domains for cpu in domain
}
name = ', '.join(map(str, rev_domains[cpu]))
title = f'Frequency transitions of CPUs {name}'
else:
title = f'Frequency transitions of CPU{cpu}'
if not df.empty:
return hv.Bars(df['transitions']).options(
title=title,
xlabel='Frequency (Hz)',
ylabel=ylabel,
invert_axes=True,
)
else:
return _hv_neutral()
def get_plot_barh(df, title):
"""Return a bar plot with the data and the title
:param data_df: dataframe with the data.
:param title: title for the plot.
:returns: A plot (bokeh plot).
:rtype: bokeh plot.
"""
# Prepare to visualize
kdims = [('alg', 'Algorithm'), ('category', 'Category'),
('ranking', 'Ranking')]
# Plot the bar
fields = ['alg', 'category', 'ranking']
data_df = df[fields].sort_values(['alg'])
data = [tuple(row) for row in data_df.values]
options = "Bars [tools=['hover'] stack_index=1 color_index=1 show_legend=False xrotation=90]"
bar = hv.Bars(data, kdims[:2], kdims[2], label=title)
return bar.opts(options)
def plot_death_rate(country):
confirmed_country = confirmed.loc[:, (slice(None), country)].sum(axis=1)
recovered_country = recovered.loc[:, (slice(None), country)].sum(axis=1)
death_country = death.loc[:, (slice(None), country)].sum(axis=1)
death_country_rate = (
death_country /
(confirmed_country + recovered_country + death_country) * 100).replace(
[np.inf, -np.inf], np.nan).dropna()
return (hv.Bars([
(i, death_country_rate.loc[i]) for i in death_country_rate.index
]).redim(x='Date', y='Percent').opts(height=400,
width=700,
fontsize={'xticks': 6},
xrotation=90,
ylim=(0, 15),
title='Death Rate (% of infected)',
tools=[rhover],
show_frame=False))
def plot_label_bars(label_df, max_x=10):
bar_list = list()
for col in label_df.columns:
if label_df[col].nunique() > max_x:
continue
label_names = label_df.groupby([col]).nunique().index.values
label_counts = label_df.groupby([col]).count().max(axis=1).values
new_bar = hv.Bars(zip(label_names, label_counts),
kdims=[col],
vdims=["count"],
group='Label Counts',
label=col)
bar_list.append(new_bar)
return hv.Layout(bar_list)
def plot_segregation(adata, save=False, filename=None):
"""Plot gabaergic and glutamaterig cell populations"""
import holoviews as hv
from holoviews import opts
import pandas as pd
hv.extension("matplotlib")
df = pd.DataFrame(adata.uns["ligands"]).loc[["GABA", "L-glutamic acid"
]].stack().reset_index()
df.columns = ["ligand", "cluster", "value"]
df = df.sort_values(by="cluster", axis=0)
opts.defaults(
opts.Bars(stacked=True,
xrotation=90,
legend_position="right",
ylabel="Ligand score"))
bars = hv.Bars(df, kdims=["cluster", "ligand"])
if save is True:
hv.save(bars, filename)
return bars
def closeness(party, graph, info, fc_info, centrality_function, show_yaxis):
closeness_df = _get_closeness(graph, info, fc_info,
centrality_function).sort_values("closeness")
closeness_df["index"] = closeness_df.index.values
columns = ["closeness", "selected", "FullName", "GroupNameEN"]
group = fc_info["Group"].iloc[0]
width = len(closeness_df) * 10
opts = CLOSENESS_OPTS.copy()
if show_yaxis:
opts["yaxis"] = True
opts["ylabel"] = "Harmonic Centrality"
return hv.Bars(closeness_df,
kdims=["index"],
vdims=columns,
label=party + " Centrality").opts(
width=width,
cmap={
0: metadata.GROUP_COLOR[group],
1: "pink"
},
**opts)
def layout_vis(stock):
perd = '1d'
end_realdata = datetime.now().strftime("%Y") + '-' + \
datetime.now().strftime("%m") + '-' + datetime.now().strftime("%d")
start_date = (datetime.now() - timedelta(days=5))
start_traindateD = start_date.strftime("%Y") + '-' + \
start_date.strftime("%m") + '-' + start_date.strftime("%d")
aord = DataAccess.data_auto_reader('^AORD', start_traindateD,
end_realdata, perd)
nikkei = DataAccess.data_auto_reader('1360.T', start_traindateD,
end_realdata, perd)
hsi = DataAccess.data_auto_reader('^HSI', start_traindateD,
end_realdata, perd)
daxi = DataAccess.data_auto_reader('DAX', start_traindateD,
end_realdata, perd)
cac40 = DataAccess.data_auto_reader('^FCHI', start_traindateD,
end_realdata, perd)
aord['Diff_price'] = aord.iloc[-1]['Close'] - aord.iloc[-1]['Open']
hsi['Diff_price'] = hsi.iloc[-1]['Close'] - hsi.iloc[-1]['Open']
nikkei[
'Diff_price'] = nikkei.iloc[-1]['Close'] - nikkei.iloc[-1]['Open']
data = [('aord', aord.iloc[-1]['Diff_price']),
('hsi', hsi.iloc[-1]['Diff_price']),
('nikkei', nikkei.iloc[-1]['Diff_price'])]
hv_asia_bar = hv.Bars(
data,
hv.Dimension('Asian Market'),
'Price Diff',
label=aord.iloc[-1]['Date'].strftime("%Y-%m-%d")).opts(height=600,
width=700)
return hv_asia_bar
def create_interactive_plot(data_dispatch, data_bars):
"""
"""
dispatch_hmap = hv.HoloMap(
{(i, k): hv.Area.stack(
hv.Overlay(
[hv.Area(data_dispatch[k, i, :, j]) for j in range(n_stack)]))
for i in range(n_i) for k in range(n_k)},
kdims=['price pv', 'price wind'])
bar_hmap = hv.HoloMap(
{(i, k): hv.Bars(data_bars, hv.Dimension('Technology'),
'Installed capacity')
for i in range(n_i) for k in range(n_k)},
kdims=['price pv', 'price wind'])
layout = hv.Layout(dispatch_hmap + bar_hmap).cols(1)
## https://github.com/ioam/holoviews/issues/1819
renderer = hv.renderer('bokeh')
# Using renderer save
renderer.save(dispatch_hmap + bar_hmap, 'interactive_modeling')
def precipitation(self, lon, lat):
"""Creates an **holoviews.Bars** object for precipitation.
Parameters
----------
lon : int or float
The longitutde of the point.
lat : int or float
Raises
------
ValueError
If either longitude or latitude or both are out of bounds.
See Also
--------
out_of_bounds : Checks if longitude and latitude are out of bounds.
"""
out_of_bounds(lon, lat, 'ClimvisHVPlot.precipitation')
self.reinitialize(lon, lat, self._overlay)
return hv.Bars(annual_cycle_for_hv(
lon, lat, variable='pre'), ).opts(tools=['hover'])
def figure_filter_class(index, weights):
"""Bar chart visualizing filter class composition"""
data = pd.DataFrame({"Weight": weights}).rename_axis(index=index)
return pn.pane.HoloViews(hv.Bars(data), sizing_mode="stretch_width")
def barchart(x, **kwargs):
return hv.Bars(zip(range(x.min(),
x.max() + 1),
np.bincount(x)[x.min():]), **kwargs)
def get_outlier_analysis(batches, output_directory, filename='ttmap'):
# plot the number of modified genes by control sample
if batches == []:
batches = ['All']
total_number_of_batches = range(len(batches))
table_with_all_samples = pd.DataFrame({})
for batch in total_number_of_batches:
path_to_file = os.path.join(output_directory, filename + 'batch' +
str(batch) + '_na_numbers_per_col.txt')
dataset = pd.read_csv(path_to_file, header=0, index_col=0, sep='\t')
dataset['Batches'] = [batches[batch]] * dataset.shape[0]
dataset['Samples'] = list(dataset.index)
table_with_all_samples = pd.concat([table_with_all_samples, dataset])
table_with_all_samples.columns = ['Counts', 'Batches', 'Samples']
key_dimensions = [('Samples', 'Sample')]
value_dimensions = [('Counts', '# modified genes'), ('Batches', 'Batch')]
viridis_cmap = process_cmap("Viridis", provider="bokeh", ncolors=len(batches))
number_modified_genes = hv.Bars(table_with_all_samples, key_dimensions, value_dimensions).opts(tools=['hover'],
color='Batches',
cmap=viridis_cmap,
xticks = 0,
legend_position='top_left',
width = 500,
responsive = True
)
# each gene is modified in x control samples. The plot below shows
# the frequency of the percentage of corrected values (by samples) per
# gene
grid_corrected_genes = pn.GridSpec(sizing_mode='stretch_both', width=500)
length_in_grid = np.int(np.ceil(np.float(len(batches))/np.float(3)))
for counter, batch in enumerate(total_number_of_batches):
path_to_file = os.path.join(output_directory, filename + 'batch' +
str(batch) + '_na_numbers_per_row.txt')
dataset = pd.read_csv(path_to_file, header=0, index_col=0, sep='\t')
if dataset.shape[1] == 1:
dataset.columns = ['Frequency']
else:
dataset.columns = ['Frequency', 'Other']
frequencies, edges = np.histogram(dataset['Frequency'], 4, range=(0,1))
histogram_frequencies = hv.Histogram((edges, frequencies), extents = (0,0,1,None)).opts(xlim=(0,1),
responsive=True,
tools=['hover'],
hooks=[fix_x_axis],
width = 220,
title = batches[batch],
xlabel = '% of corrected genes',
)
index_column = np.unravel_index(counter, (length_in_grid, 3))
grid_corrected_genes[index_column[0], index_column[1]] = histogram_frequencies
grid_corrected_genes[length_in_grid, :] = number_modified_genes
return grid_corrected_genes
# n keywords per book count
vals, counts = np.unique(ndfIDF['n_keywords'], return_counts=True)
tagcounts = pd.DataFrame({'n_keywordsPerBook': vals, 'count': counts})
tagcounts['pct'] = tagcounts['count'] / tagcounts['count'].sum()
#%% create, save, display histograms for keywords, clusters, and keywordsPerBook
print('make, display, save keyword and concept histograms')
kwdBars = hv.Bars(tags_df, 'keywords', 'count').options(
title_format='Keywords',
labelled=['y'],
color=hv.Cycle(values=Colors),
color_index='keywords',
#invert_axes=True, invert_yaxis=True,
width=1200,
height=400,
tools=['hover'],
xrotation=60,
show_legend=False,
show_grid=True)
conceptBars = hv.Bars(concepts_df, 'concepts', 'count').options(
title_format='Concepts',
labelled=['y'],
color=hv.Cycle(values=Colors),
color_index='concepts',
#invert_axes=True, invert_yaxis=True,
width=1200,
height=300,
tools=['hover'],
import pandas as pd
import holoviews as hv
%load_ext holoviews.ipython
df = pd.read_csv('data.csv')
bars = []
time = df['Year'].unique()
for t in time:
bar = hv.Bars(df[df['Year']==t])
bars.append((t,bar))
hmap = hv.HoloMap(bars,'Year').opts(aspect=1, fig_inches=6)
res = hv.output(hmap, holomap='gif', fps=3)
def seriesToHistogram(data,
fileName='histogram',
graphTitle='Distribution',
sortedAscending=True,
logScale=False,
xlbl='Value',
ylbl='Frequency'):
data2 = data.replace(' ', np.nan)
data2.dropna(inplace=True)
# data2.sort_values(inplace=True)
try:
histData = pd.to_numeric(data2, errors='raise')
numericData = True
except:
histData = data2
numericData = False
if numericData:
# frequencies, edges = np.histogram(gpas, int((highest - lowest) / 0.1), (lowest, highest))
dataList = histData.tolist()
frequencies, edges = np.histogram(dataList,
(int(math.sqrt(len(dataList))) if
(len(dataList) > 30) else
(max(len(dataList) // 3, 1))),
(min(dataList), max(dataList)))
#print('Values: %s, Edges: %s' % (frequencies.shape[0], edges.shape[0]))
if logScale:
frequencies = [
math.log10(freq) if freq > 0 else freq for freq in frequencies
]
ylbl += ' (log 10 scale)'
histo = hv.Histogram((edges, frequencies))
histo.opts(
opts.Histogram(xlabel=xlbl,
ylabel=ylbl,
title=graphTitle,
fontsize={
'title': 40,
'labels': 20,
'xticks': 20,
'yticks': 20
}))
subtitle = 'mean: ' + str(round(sum(dataList) / len(dataList),
3)) + ', n = ' + str(len(dataList))
hv.output(size=250)
graph = hv.render(histo)
graph.add_layout(
Title(text=subtitle,
text_font_style="italic",
text_font_size="30pt"), 'above')
output_file(outDir + fileName + '.html', mode='inline')
save(graph)
show(graph)
# JH: Adds some specific display components when not in a graphical program.
# JH: Consider a separate function for the two cases.
if not edmApplication:
hv.output(size=300)
histo.opts(toolbar=None)
graph = hv.render(histo)
graph.add_layout(
Title(text=subtitle,
text_font_style="italic",
text_font_size="30pt"), 'above')
export_png(graph, filename=outDir + fileName + '.png')
else:
barData = histData.value_counts(dropna=False)
dictList = sorted(zip(barData.index, barData.values),
key=lambda x: x[sortedAscending])
# print(dictList)
bar = hv.Bars(dictList)
bar.opts(opts.Bars(xlabel=xlbl, ylabel=ylbl, title=graphTitle))
subtitle = 'n = ' + str(len(dictList))
hv.output(size=250)
graph = hv.render(bar)
graph.add_layout(
Title(text=subtitle,
text_font_style="italic",
text_font_size="30pt"), 'above')
output_file(outDir + fileName + '.html', mode='inline')
save(graph)
show(graph)
# JH: Consider a bool exportPng=True when calling from outside edmAppliation
if not edmApplication:
hv.output(size=300)
bar.opts(toolbar=None)
graph2 = hv.render(bar)
graph2.add_layout(
Title(text=subtitle,
text_font_style="italic",
text_font_size="30pt"), 'above')
export_png(graph2, filename=outDir + fileName + '.png')
hv.output(size=125)
def plot_pozos_tipo():
dims_eur_baja = dict(kdims='mes', vdims=['EUR_baja_L','EUR_baja_H'])
env_eur_baja = hv.Area(perfil, label='EUR Baja', **dims_eur_baja)
env_eur_baja.opts(alpha=0.3,
color='red',
fontscale=1.5)
linea_eur_baja = hv.Curve(perfil.EUR_baja_M)
linea_eur_baja.opts(color='red',
line_dash='dotted')
dims_eur_media = dict(kdims='mes', vdims=['EUR_media_L','EUR_media_H'])
env_eur_media= hv.Area(perfil, label='EUR Media', **dims_eur_media)
env_eur_media.opts(alpha=0.3,
color='blue',
fontscale=1.5)
linea_eur_media = hv.Curve(perfil.EUR_media_M)
linea_eur_media.opts(color='blue',
line_dash='dotted')
dims_eur_alta = dict(kdims='mes', vdims=['EUR_alta_L','EUR_alta_H'])
env_eur_alta = hv.Area(perfil, label='EUR Alta', **dims_eur_alta)
env_eur_alta.opts(alpha=0.3,
color='green',
fontscale=1.5)
linea_eur_alta = hv.Curve(perfil.EUR_alta_M)
linea_eur_alta.opts(color='green',
line_dash='dotted')
elementos_tabla=dict(indice=resumen.index[6:13], valores=resumen[6:13])
tabla_resumen = hv.Table(elementos_tabla,'indice','valores')
tabla_resumen.opts(height=500,fontscale=20)
plot_eur = env_eur_baja * linea_eur_baja * env_eur_media * linea_eur_media * env_eur_alta * linea_eur_alta
plot_eur.opts(legend_position='top_left')
elementos_tipos = dict(tipo=pd.unique(tipos.tipo), numero=tipos.tipo.value_counts())
plot_tipos = hv.Bars(elementos_tipos,'tipo','numero')
plot_tipos.opts(color='tipo',
cmap='Set1',
fontscale=1.5)
#fill_color=factor_cmap('tipo', palette=Spectral6, factors=elementos_tipos['tipo']))
layout = plot_eur + plot_tipos + tabla_resumen
fig1 = hv.render(layout)
hv.output(layout, backend='bokeh', fig='html', size=200)
hv.save(layout, 'resumen_produccion.html')
dims_baja = dict(kdims='mes', vdims=['baja_L','baja_H'])
env_baja = hv.Area(perfil, label='Envolvente', **dims_baja)
env_baja.opts(alpha=0.3,color='red',fontscale=1.5,title='Perfil BAJA Qoi')
linea_baja = hv.Curve(perfil.baja_M,label='P50')
linea_baja.opts(color='red',line_dash='dotted')
dims_media = dict(kdims='mes', vdims=['media_L','media_H'])
env_media= hv.Area(perfil, label='Envolvente', **dims_media)
env_media.opts(alpha=0.3,color='blue',fontscale=1.5,title='Perfil MEDIA Qoi')
linea_media = hv.Curve(perfil.media_M,label='P50')
linea_media.opts(color='blue',line_dash='dotted')
dims_alta = dict(kdims='mes', vdims=['alta_L','alta_H'])
env_alta = hv.Area(perfil, label='Envolvente', **dims_alta)
env_alta.opts(alpha=0.3,color='green',fontscale=1.5,title='Perfil ALTA Qoi')
linea_alta = hv.Curve(perfil.alta_M,label='P50')
linea_alta.opts(color='green',line_dash='dotted')
plots_perfiles = env_baja * linea_baja + env_media * linea_media + env_alta * linea_alta
fig2 = hv.render(plots_perfiles)
hv.output(plots_perfiles, backend='bokeh', fig='html', size=200)
hv.save(plots_perfiles, 'curvas_tipo.html')
return
'Asian',
'URM',
'White',
'International',
'Unknown',
]
p_bars = hv.Bars(df_bar,
kdims=['Year', 'variable'],
vdims=['frac', 'Level', 'USonly',
'Group']).redim.values(variable=stack_order).groupby(
['Level', 'USonly', 'Group']).opts(
cmap=cmap,
labelled=[],
tools=['hover'],
stacked=True,
width=800,
height=400,
yaxis=None,
ylim=(None, None),
title='',
legend_offset=(0, 0),
legend_position="bottom",
show_legend=True,
)
# In[11]:
df_bar = df.apply(flip_y, axis=1)
def format_pct(x):
def showmissingpertrack(data, percentage=False):
"show missing per track"
if percentage:
return hv.Bars(data.delta.isna().sum(level=0) /
data.delta.count(level=0))
return hv.Bars(data.delta.isna().sum(level=0))
subset3["Course ID #"] = subset3["courseid_num"]
plot_opts = dict(show_legend=False,
color_index='Course Currently Selected',
title="Engagement Scores Across Your Company Courses",
width=600,
xlabel='Course ID #',
ylabel='Engagement Score',
ylim=(0, 110),
xrotation=45,
tools=['hover'])
style_opts = dict(box_color=hv.Cycle(['#30a2da', '#fc4f30']))
bars = hv.Bars(
subset3, hv.Dimension('Course ID #'),
['Engagement Score', 'Course Currently Selected', 'Number of Users'])
bars = bars.opts(plot=plot_opts, style=style_opts)
st.write(hv.render(bars))
##############################################################################
#### Writing current engagement score ####
##############################################################################
subset2 = subset[subset['courseid_num'] == course_selection]
subset2.reset_index(drop=True, inplace=True)
pd.DataFrame(
confusion_matrix(
digits_y_sparse.numpy().argmax(axis=1), digits_y_hat.argmax(axis=1)
),
index=range(1, 10),
columns=range(1, 10),
)
#%%
lead_prob = digits_tree.leaf_probabilty(digits_X)
P = tf.concat([tf.reshape(x, (-1, 1)) for x in lead_prob], 1)
pd.np.random.choice(range(1000), 5)
hv.Bars(tf.random.shuffle(P)[1, :].numpy())
#%%
prototype_labels = []
for s, p in zip(digits_tree.leaf(digits_X), digits_tree.leaf_probabilty(digits_X)):
prototype_labels.append(s * tf.reshape(p, (-1, 1)))
prototype_labels = list(
map(lambda x: (tf.reduce_mean(x, 0).numpy().argmax(0)), prototype_labels)
)
prototypes = list(map(lambda x: tf.reduce_mean(x, 0), digits_tree.prototype(digits_X)))
#%%
images = []
for i, (proto, label) in enumerate(zip(prototypes, prototype_labels)):
def stacked_bar_plot(SBJ, WL):
sleep_df_TR = pd.DataFrame(columns=['sleep value', 'sleep stage'])
for RUN in ['SleepAscending', 'SleepDescending', 'SleepRSER']:
DATA_df = load_sleep_stage_data(SBJ,
RUN,
WL,
window=False,
fill_TR=False)
temp_df = DATA_df[['sleep value', 'sleep stage']].copy()
sleep_df_TR = sleep_df_TR.append(temp_df).reset_index(drop=True)
wake_df_TR = pd.DataFrame(columns=['sleep value', 'sleep stage'])
for RUN in ['WakeAscending', 'WakeDescending', 'WakeRSER']:
DATA_df = load_sleep_stage_data(SBJ,
RUN,
WL,
window=False,
fill_TR=False)
temp_df = DATA_df[['sleep value', 'sleep stage']].copy()
wake_df_TR = wake_df_TR.append(temp_df).reset_index(drop=True)
sleep_df_WIN = pd.DataFrame(columns=['sleep value', 'sleep stage'])
for RUN in ['SleepAscending', 'SleepDescending', 'SleepRSER']:
DATA_df = load_sleep_stage_data(SBJ,
RUN,
WL,
window=True,
fill_TR=False)
temp_df = DATA_df[['sleep value', 'sleep stage']].copy()
sleep_df_WIN = sleep_df_WIN.append(temp_df).reset_index(drop=True)
wake_df_WIN = pd.DataFrame(columns=['sleep value', 'sleep stage'])
for RUN in ['WakeAscending', 'WakeDescending', 'WakeRSER']:
DATA_df = load_sleep_stage_data(SBJ,
RUN,
WL,
window=True,
fill_TR=False)
temp_df = DATA_df[['sleep value', 'sleep stage']].copy()
wake_df_WIN = wake_df_WIN.append(temp_df).reset_index(drop=True)
percent_df = pd.DataFrame(
columns=['Time', 'Run', 'Sleep Stage', 'Percent'])
sleep_list_TR = list(sleep_df_TR['sleep stage'])
for stage in ['Wake', 'Stage 1', 'Stage 2', 'Stage 3', 'Undetermined']:
percent_df.loc[len(percent_df.index)] = [
'TR', 'Sleep', stage,
(sleep_list_TR.count(stage)) / len(sleep_list_TR) * 100
]
wake_list_TR = list(wake_df_TR['sleep stage'])
for stage in ['Wake', 'Stage 1', 'Stage 2', 'Stage 3', 'Undetermined']:
percent_df.loc[len(percent_df.index)] = [
'TR', 'Wake', stage,
(wake_list_TR.count(stage)) / len(wake_list_TR) * 100
]
sleep_list_WIN = list(sleep_df_WIN['sleep stage'])
for stage in ['Wake', 'Stage 1', 'Stage 2', 'Stage 3', 'Undetermined']:
percent_df.loc[len(percent_df.index)] = [
'Window', 'Sleep', stage,
(sleep_list_WIN.count(stage)) / len(sleep_list_WIN) * 100
]
wake_list_WIN = list(wake_df_WIN['sleep stage'])
for stage in ['Wake', 'Stage 1', 'Stage 2', 'Stage 3', 'Undetermined']:
percent_df.loc[len(percent_df.index)] = [
'Window', 'Wake', stage,
(wake_list_WIN.count(stage)) / len(wake_list_WIN) * 100
]
color_key = {
'Wake': 'orange',
'Stage 1': 'yellow',
'Stage 2': 'green',
'Stage 3': 'blue',
'Undetermined': 'gray'
}
output = hv.Bars(percent_df,
kdims=['Run', 'Sleep Stage', 'Time'],
group='Time').opts(cmap=color_key,
xlabel=' ',
ylim=(0, 100),
width=800,
height=350,
title='Sleep Stage Bar Graph for ' +
SBJ)
return output
return percent_df
all_percent_df = all_sleep_data_TR(sub_list)
color_key = {
'Wake': 'orange',
'Stage 1': 'yellow',
'Stage 2': 'green',
'Stage 3': 'blue',
'Undetermined': 'gray'
}
hv.Bars(all_percent_df,
kdims=['Run', 'Sleep_Stage'
]).opts(cmap=color_key,
xlabel=' ',
ylim=(0, 100),
width=800,
height=350,
title='Sleep Stage Bar Graph for All Subjects')
# ***
# ## Comparing Percent of Sleep Stages by TR vs Window
# To see if the "winner takes all" method of determining sleep stage per window we plot both bar plots on top of each other.
@pn.depends(SubjSelect.param.value, WindowSelect.param.value)
def sleep_bar_graph_WIN(SBJ, WL):
sleep_df = pd.DataFrame(columns=['sleep value', 'sleep stage'])
for RUN in ['SleepAscending', 'SleepDescending', 'SleepRSER']:
DATA_df = load_sleep_stage_data(SBJ,
RUN,
renderer = hv.renderer('bokeh')
df1 = df[df['size'] != 'Varies with device']
df1.loc[df1['size'].str[-1] == 'k',
['size']] = pd.to_numeric(df1['size'].str[:-1], errors='coerce') / 1000
df1['size'] = df1['size'].str[0:-1]
df1['size'] = pd.to_numeric(df1['size'], errors='coerce')
category_size = df1[['category', 'size']].dropna()
category_size = category_size.groupby('category', as_index=False).mean()
category_size.set_index('category', inplace=True)
v = category_size["size"].values.tolist()
i = category_size["size"].index.tolist()
bars = hv.Bars((i, v), hv.Dimension('category'),
'size').opts(tools=['hover'],
xformatter=formatter,
show_legend=False,
fill_color=dim('category').str(),
cmap='coolwarm') # '#E933FF'
t = (bars.relabel('Avg. size by category').opts(invert_axes=True,
height=650,
width=1000))
renderer.save(t, "./Data/average_size")
# ***************************************************************************
def _get_bokeh_chart(self,
x_field,
y_field,
chart_type,
label,
opts,
style,
options={},
**kwargs):
"""
Get a Bokeh chart object
"""
if isinstance(x_field, list):
kdims = x_field
else:
kdims = [x_field]
if isinstance(y_field, list):
vdims = y_field
else:
vdims = [y_field]
args = kwargs
args["data"] = self.df
args["kdims"] = kdims
args["vdims"] = vdims
if label is not None:
args["label"] = label
else:
if self.label is not None:
args["label"] = self.label
chart = None
try:
if chart_type == "line":
chart = hv.Curve(**args)
if chart_type == "hline":
chart = self._hline_bokeh_(y_field)
elif chart_type == "point":
chart = hv.Scatter(**args)
elif chart_type == "area":
chart = hv.Area(**args)
elif chart_type == "bar":
chart = hv.Bars(**args)
elif chart_type == "hist":
chart = hv.Histogram(**args)
elif chart_type == "errorBar":
chart = hv.ErrorBars(**args)
elif chart_type == "heatmap":
chart = hv.HeatMap(**args)
elif chart_type == "lreg":
chart = self._lreg_bokeh(**args)
elif chart_type == "sline":
window_size, y_label = options["window_size"],
options["y_label"]
chart = self._sline_bokeh(window_size, y_label)
if chart is None:
self.err("Chart type " + chart_type + " unknown",
self._get_bokeh_chart)
return
endchart = chart(plot=opts, style=style)
return endchart
except DataError as e:
msg = "Column not found in " + x_field + " and " + y_field
self.err(e, self._get_bokeh_chart, msg)
except Exception as e:
self.err(e)
pool = Pool()
json_data = pool.map(get_json_data, worker_keys)
sg_client.describe_workteam(WorkteamName=workTeamName)
response = cognito_client.list_users(UserPoolId=user_pool_id)
user_dict = {}
for user in response['Users']:
for attr in user['Attributes']:
if attr['Name'] == 'sub':
user_dict[attr['Value']] = user
labels = []
for data in json_data:
for a in data['answers']:
sub = a['workerMetadata']['identityData']['sub']
labels.append(user_dict[sub]['Username'])
renderer = hv.renderer('bokeh')
bars = hv.Bars(Counter(labels)).opts(
width=width,
height=height,
title='Labeled/Unlabeled: ' + str(labeled_so_far) + '/' + str(unlabeled))
layout = bars
doc = renderer.server_doc(layout)
doc.title = 'Labeling Job Status'
for i in open(base_dir + 'kyoto-train.en', 'r').readlines()
]
df = pd.DataFrame({"ja": ja, "en": en}).iloc[0:3000, :]
# Japanese PreProcessing
df['ja_preprocessed'] = df['ja'].apply(lambda x: ja_preprocess(x))
# English PreProcessing
df['en_preprocessed'] = df['en'].apply(lambda x: en_preprocess(x))
# English tfidf / bow features
en_bow = bow_features(df['en_preprocessed'],
_max_features=10,
_max_ngrams=1)
en_tfidf = tfidf_features(df['en_preprocessed'],
_max_features=10,
_max_ngrams=1)
# English Ngram Count
en_ngram = ngram_count(df['en_preprocessed'], ngram=1, common_num=30)
# Ngram Count Bar Plot
en_ngram_graph = hv.Bars(en_ngram[::-1]) \
.opts(opts.Bars(title="Ngram Count", color="red", xlabel="Unigrams", ylabel="Count", width=400, height=600, show_grid=True, invert_axes=True))
hv.save(en_ngram_graph, 'en_graph.html')
# Japanese WordCloud
wordCloud(df['ja_preprocessed'],
_font_path='NotoSansCJKjp-Regular.otf',
_output_file='wordCloud_ja.png')
# English WordCloud
wordCloud(df['en_preprocessed'], _output_file='wordCloud_en.png')
from bokeh.plotting import figure, output_file, show
import holoviews as hv
hv.extension('bokeh')
# prepare some data
x = [1, 2, 3, 4, 5]
y = [6, 7, 2, 4, 5]
# output to static HTML file
output_file("lines.html")
data = [('one',8),('two', 10), ('three', 16), ('four', 8), ('five', 4), ('six', 1)]
bars = hv.Bars(data, hv.Dimension('Car occupants'), 'Count')
"""
# create a new plot with a title and axis labels
p = figure(title="simple line example", x_axis_label='x', y_axis_label='y', toolbar_location=None)
# add a line renderer with legend and line thickness
p.line(x, y, legend="Temp.", line_width=2)
"""
# show the results
show(bars)
