def hydrograph_exercise():
h = Hydrograph(ER, DD, dt=0.5)
dd = Dropdown(options={
'rainfall': 1,
'unit hydrograph': 2
},
value=1,
description='highlight')
items = h.linked_widgets()
hint = items.pop('hint')
its = list(items.values())
N = int(np.ceil(len(its) / 3.))
items_list = [
VBox(its[:N]),
VBox(its[N:2 * N]),
VBox(its[2 * N:]),
VBox([dd, hint])
]
items.update({'dd': dd, 'hint': hint})
io1 = interactive_output(h.rainfall, items)
io2 = interactive_output(h.unit_hydrograph, items)
io3 = interactive_output(h.streamflow, items)
io4 = interactive_output(h.hintbox, items)
return VBox([HBox([io1, io2, io3]), io4, HBox(items_list)])
def linear_example_with_loss():
m, b = get_m_b_sliders()
out = widgets.interactive_output(lambda m, b: plot_it(x, y, linear, m, b),
{
'm': m,
'b': b
})
loss_text = widgets.interactive_output(
lambda m, b: display(
widgets.FloatText(value=round(mse(y, linear(x, m, b)), 3),
description='m. s. e. loss:',
disabled=False,
layout={'width': '100%'})), {
'm': m,
'b': b
})
loss_plot(None, None, reset=True)
loss_display = widgets.interactive_output(
lambda m, b: loss_plot(mse(y, linear(x, m, b))), {
'm': m,
'b': b
})
display(
widgets.VBox([
widgets.HBox([out, loss_display]),
widgets.VBox([m, b, loss_text])
],
layout=widgets.Layout(align_items='center')))
def explore_single_portrait(self):
k_slider = widgets.IntSlider(min=2, max=14)
cols = widgets.Dropdown(
options=list(self.data.joined_data.columns.drop(["Gemeinde"])))
input_ui = widgets.HBox([k_slider, cols])
table_out = widgets.interactive_output(self.show_portrait_table, {
'k': k_slider,
'col': cols
})
boxplot_out = widgets.interactive_output(self.show_portrait_boxplot, {
'k': k_slider,
'col': cols
})
tab_headers = ["table", "boxplot"]
tab_children = [
table_out,
boxplot_out,
]
tabbed_view = widgets.Tab()
tabbed_view.children = tab_children
for i, title in enumerate(tab_headers):
tabbed_view.set_title(i, title)
return display(input_ui, tabbed_view)
def __add_button_clicked(self, b):
with self.add_button_output:
clear_output()
if len(self.list_of_join_tables) < 1:
self.list_of_join_tables.append(
widgets.HBox([self.table_one, self.join_button]))
self.table_one.options = [self.table_one.value]
self.join_button.layout.visibility = 'hidden'
join_table = widgets.Dropdown(
options=self.__BFS(
self.joinable_dictionary,
self.list_of_join_tables[-1].children[0].value),
description='Table',
layout=widgets.Layout(flex='1 1 auto', width='auto'),
style={'description_width': 'initial'})
join_button = widgets.Button(
description="ADD",
icon='',
style=widgets.ButtonStyle(button_color='#E58975'))
join_button.on_click(self.__add_button_clicked)
self.list_of_join_tables.append(
widgets.HBox([join_table, join_button]))
widgets.interactive_output(self.__change_columns,
{'table': join_table})
for table in self.list_of_join_tables[1:-1]:
table.children[0].options = [table.children[0].value]
table.children[1].layout.visibility = 'hidden'
for x in self.list_of_join_tables[1:]:
display(x)
self.view_query_button.click()
def __get_table(self, service):
try:
self.service = pyvo.dal.TAPService(service)
table_query = "SELECT table_name FROM tap_schema.tables"
tables = self.service.search(table_query)
self.table_list = [x.decode() for x in list(tables['table_name'])]
except Exception:
print("Service not found")
return
self.tables_dropdown = widgets.Dropdown(
options=self.table_list,
description='Table',
layout=widgets.Layout(flex='1 1 auto', width='auto'),
style={'description_width': 'initial'})
self.join_button = widgets.Button(
description="JOIN",
icon='',
style=widgets.ButtonStyle(button_color='#E58975'))
self.join_button.on_click(self.__join_button_clicked)
self.list_of_tables.append(self.tables_dropdown)
self.table_text = widgets.Text(value=self.list_of_tables[0].value,
description='')
self.columns_select = widgets.interactive_output(
self.__get_select_columns, {'table_text': self.table_text})
self.columns = widgets.interactive_output(
self.__set_columns, {'table_text': self.table_text})
self.trigger_column = widgets.interactive_output(
self.__trigger_column_widget, {'table': self.tables_dropdown})
display(widgets.HBox([self.tables_dropdown, self.join_button]),
self.table_join_out, self.columns_select, self.columns)
def _perform_bigram(self, condition: bool):
if condition:
top_bigram_widget = self.widget.int_slider(
minimum=1,
maximum=100,
step=1,
value=10,
description="Word Range:")
interact(self._bigram_stop_word_interaction,
condition=widgets.Checkbox(
description="Include Stop words in analysis"))
widgets.interactive_output(self._bigram_interaction,
{'top_bigram': top_bigram_widget})
display(top_bigram_widget)
bigram_button = widgets.Button(description='Start Analysis',
tooltip='Start Bigram Analysis',
button_style='info')
bigram_button.on_click(self._start_bigram)
display(bigram_button)
def multi_checkbox_widget(sample_names):
flatten = itertools.chain.from_iterable #tool to flatten a nested list
names = []
checkbox_objects = []
label_objects = []
for name in sample_names:
checkbox_objects.append(
widgets.Checkbox(layout=widgets.Layout(width='50%')))
label_objects.append(
widgets.Label(name, layout=widgets.Layout(width='25%')))
names.append(name)
arg_dict = {
names[i]: checkbox
for i, checkbox in enumerate(checkbox_objects)
}
labels_checkboxes = list(flatten(zip(label_objects, checkbox_objects)))
ui = widgets.HBox(labels_checkboxes,
layout=widgets.Layout(flex_flow='row wrap'))
selected_data = []
def select_data(**kwargs):
selected_data.clear()
for key in kwargs:
if kwargs[key] is True:
selected_data.append(key)
display(ui)
widgets.interactive_output(select_data, arg_dict)
return (selected_data)
def spectrogram_explorer(ax, signal):
from IPython.display import display
import ipywidgets as ipyw
NFFT = ipyw.IntSlider(value=256, min=8, max=1024, step=1, description="NFFT:")
shift = ipyw.IntSlider(value=128, min=8, max=1024, step=1, description="shift:")
compress = ipyw.FloatLogSlider(value=0, base=10, min=-2, max=5, step=0.2, description="compress:")
thresh = r_max = osc.max() * 1.2
thresh_w = ipyw.FloatSlider(value=thresh, min=0, max=r_max, step=r_max / 100,
description="Threshold:", continuous_update=False)
display(thresh_w)
ax1.plot(time, osc)
line, = ax1.plot((time[0], time[-1]), (thresh, thresh), 'k')
points, = ax1.plot([], [], 'ro')
def update(thresh):
from quickspikes.tools import filter_times
line.set_ydata((thresh, thresh))
det = qs.detector(thresh, 40)
spike_t = filter_times(det.send(osc), 10, osc.size - 20)
if spike_t:
spike_t = np.asarray(spike_t)
spike_w = np.asarray(qs.peaks(osc, spike_t, 10, 20))
plot_some_spikes(ax2, spike_w, color='k', alpha=0.2)
points.set_xdata(time[spike_t])
points.set_ydata(osc[spike_t])
ax1.figure.canvas.draw()
ipyw.interactive_output(update, {"thresh": thresh_w})
def spike_detector(ax1, ax2, data, time):
from IPython.display import display
import ipywidgets as ipyw
import quickspikes as qs
osc = data.astype('d')
thresh = r_max = osc.max() * 1.2
thresh_w = ipyw.FloatSlider(value=thresh, min=0, max=r_max, step=r_max / 100,
description="Threshold:", continuous_update=False)
display(thresh_w)
ax1.plot(time, osc)
line, = ax1.plot((time[0], time[-1]), (thresh, thresh), 'k')
points, = ax1.plot([], [], 'ro')
def update(thresh):
from quickspikes.tools import filter_times
line.set_ydata((thresh, thresh))
det = qs.detector(thresh, 40)
spike_t = filter_times(det.send(osc), 10, osc.size - 20)
if spike_t:
spike_t = np.asarray(spike_t)
spike_w = np.asarray(qs.peaks(osc, spike_t, 10, 20))
plot_some_spikes(ax2, spike_w, color='k', alpha=0.2)
points.set_xdata(time[spike_t])
points.set_ydata(osc[spike_t])
ax1.figure.canvas.draw()
ipyw.interactive_output(update, {"thresh": thresh_w})
def app(self):
self._out = Output(layout=Layout(width="{}px".format(self.width+2),
height="{}px".format(self.height+2),
border='1px solid black'))
sld_frame = IntSlider(description="Frame",
min=0, max=self.num_frames-1,
step=1, value=self.active_frame,
layout=Layout(width="{}px".format(self.width)))
btn_play = Play(description="Animate",
min=0, max=self.num_frames-1,
step=1, value=self.active_frame,
interval=200)
btn_fwrd = Button(description="▶▶", layout=Layout(width="auto"))
btn_revs = Button(description="◀◀", layout=Layout(width="auto"))
drd_model = Dropdown(description="Model",
options=list(range(self.num_models)),
value=self.active_model)
drd_style = Dropdown(description="Style",
options=['sticks', 'ballsticks', 'vanderwaals',
'default'],
value='default')
int_delay = IntText(description="Delay (ms)", value=100,
layout=Layout(max_width="150px"))
int_step = BoundedIntText(description="Step", value=1,
min=1, max=self.num_frames,
layout=Layout(max_width="150px"))
ui = VBox([HBox([drd_model, drd_style]),
self._out,
HBox([VBox([int_step, int_delay]),
VBox([sld_frame,
HBox([btn_revs, btn_play, btn_fwrd])],
layout=Layout(align_items='center'))])],
layout=Layout(align_items='center'))
def frame_fwrd(btn):
if (sld_frame.value < sld_frame.max):
sld_frame.value += 1
def frame_revs(btn):
if (sld_frame.value > sld_frame.min):
sld_frame.value -= 1
def frame_change(model, frame, style):
with self._out:
self.update(model=model, frame=frame, style=style)
btn_fwrd.on_click(frame_fwrd)
btn_revs.on_click(frame_revs)
jslink((btn_play, "value"), (sld_frame, "value"))
jslink((int_delay, "value"), (btn_play, "interval"))
jslink((int_step, "value"), (btn_play, "step"))
interactive_output(frame_change, {'model': drd_model,
'style': drd_style,
'frame': sld_frame})
IPython.display.display(ui)
def indict_dsp(inpt, depth):
"""
INPUTS
inpt (list of (lists) of dicts) diction
depth (int) number of df
OUTPUTS
displayed df's with widgets
"""
w_sel = ipw.IntSlider(min=1,
max=len(inpt),
value=1,
step=1,
description='Results Dataset: ',
width='auto',
style={'description_width': 'initial'})
d_sel = ipw.IntSlider(min=1,
max=depth,
value=1,
step=1,
description='Equation: ',
width='auto',
style={'description_width': 'initial'})
def in_dcts_dsp(in_dcts, depth, w, d):
if depth == 1:
display(in_dcts[w - 1])
elif depth > 1:
display(in_dcts[w - 1][d - 1])
dict_out = ipw.interactive_output(in_dcts_dsp, {
'in_dcts': ipw.fixed(inpt),
'w': w_sel
})
if depth == 1:
dict_out = ipw.interactive_output(
in_dcts_dsp, {
'in_dcts': ipw.fixed(inpt),
'w': w_sel,
'depth': ipw.fixed(depth),
'd': ipw.fixed(1)
})
bx = ipw.VBox([w_sel, dict_out])
elif depth > 1:
dict_out = ipw.interactive_output(
in_dcts_dsp, {
'in_dcts': ipw.fixed(inpt),
'w': w_sel,
'depth': ipw.fixed(depth),
'd': d_sel
})
bx = ipw.VBox([d_sel, w_sel, dict_out])
return bx
def getInstanceOfIntegerSlider(self, min=0, max=15, onUpdate=None):
self.widgets = IntSlider(min=min, max=max)
ui = HBox([self.widgets])
if onUpdate == None:
out = interactive_output(self.ListenerDefault,
{'value': self.widgets})
else:
out = interactive_output(onUpdate, {'value': self.widgets})
display(ui, out)
return self.widgets
def interact_LD(self, L_dict, D_dict):
# closure just capture self in function
def update(L, D):
self.update_plot(L, D)
layout = Layout(width="50%")
lw = FloatSlider(**L_dict, layout=layout, description="L")
dw = FloatSlider(**D_dict, layout=layout, description="D")
box = HBox([lw, dw])
interactive_output(update, {'L': lw, 'D': dw})
display(box)
def circle_and_the_line():
m, b = get_m_b_sliders()
out = widgets.interactive_output(
lambda m, b: plot_proba(class_inner, class_outer, linear, m, b), {
'm': m,
'b': b
})
loss_plot(None, None, reset=True)
loss_display = widgets.interactive_output(
lambda m, b: loss_plot(np.mean([
binary_crossentropy(
0, linear_sigmoid(class_inner_x, class_inner_y, m, b)),
binary_crossentropy(
1, linear_sigmoid(class_outer_x, class_outer_y, m, b))
]),
loss_name='b. c. e.'), {
'm': m,
'b': b
})
acc_text = widgets.interactive_output(
lambda m, b: display(
widgets.FloatText(value=round(
np.mean([
1 - accuracy(class_inner[1], linear(class_inner[0], m, b)),
accuracy(class_outer[1], linear(class_outer[0], m, b))
]), 3),
description='accuracy:',
disabled=False,
layout={'width': '100%'})), {
'm': m,
'b': b
})
bce_text = widgets.interactive_output(
lambda m, b: display(
widgets.FloatText(value=round(
np.mean([
binary_crossentropy(
0, linear_sigmoid(class_inner_x, class_inner_y, m, b)),
binary_crossentropy(
1, linear_sigmoid(class_outer_x, class_outer_y, m, b))
]), 3),
description='b. c. e. loss:',
disabled=False,
layout={'width': '100%'})), {
'm': m,
'b': b
})
display(
widgets.VBox([
widgets.HBox([out, loss_display]),
widgets.VBox([m, b, acc_text, bce_text])
],
layout=widgets.Layout(align_items='center')))
def h(b):
if b=='From Dataset':
automatic_entry=widgets.IntText(value=1,description='Enter row number of query:',
style = {'description_width': 'initial'},layout= dict(max_width='250px'))
listautomatic_entry=[automatic_entry]
display(automatic_entry)
def queryvalues1(**kwargs):
list3=list(kwargs.values())
outcome_index=dataname.columns.get_loc(outcome_name)
rowdata=[]
for i in dataname.loc[list3[0] , : ]:
rowdata.append(i)
rowdata.pop(outcome_index)
explore.queryvaluestouse=rowdata
args3 = {
f'arg{i}': child
for i, child in enumerate(listautomatic_entry) }
outtest3=widgets.interactive_output(queryvalues1, args3)
elif b=='Manually Enter':
inputq=[]
inputs=[]
index=-1
for i in feature_names:
index+=1
if i in cont_feat:
cont_text=widgets.FloatText(value=0,layout=dict(max_width='250px'))
inputs.append(cont_text)
else:
noncont_dropdown=widgets.Dropdown(options=dataname[i].unique(),layout= dict(max_width='250px'))
inputs.append(noncont_dropdown)
justinputs=VBox(children=inputs)
inputsandlabels=HBox(children=[justlabels,justinputs])
inputq.append(inputsandlabels)
query=VBox(children=inputq)
display(query)
def queryvalues(**kwargs):
list2=list(kwargs.values())
explore.queryvaluestouse=list2
args2 = {
f'arg{i}': child
for i, child in enumerate(inputs) }
outtest2=widgets.interactive_output(queryvalues, args2)
def history_ui():
date_wid = widgets.DatePicker(description='Pick a Date',
value=dt.datetime.today(),
disabled=False)
def filter_data(date):
d = read(dr['MAT']+'Timesheet.pkl')
date=dt.datetime(date.year,date.month,date.day)
c1=(d['From']>date)*(d['To']<=date+pd.to_timedelta('23:59:59'))
c11=d[c1]
idx=[i for i in d.index if d['To'][i].day==d['From'][i].day+1]
c12=d.loc[idx]
c10=c12[(c12['To']>=date)*(c12['To']<=date+pd.to_timedelta('23:59:59'))]
for j in ['From','To']:
c11[j]=[c11[j].iloc[i].strftime('%H:%M:%S') for i in range(len(c11[j]))]
c13=pd.concat((c10,c11))
display(c13)
def total_df(date):
d = read(dr['MAT']+'Timesheet.pkl')
date=dt.datetime(date.year,date.month,date.day)
c1=(d['From']>pd.to_datetime(date))*(d['To']<=pd.to_datetime(date)+pd.to_timedelta('23:59:59'))
c11=d[c1]
idx=[i for i in d.index if d['To'][i].day==d['From'][i].day+1]
c12=d.loc[idx]
c10=c12[(c12['To']>=date)*(c12['To']<=date+pd.to_timedelta('23:59:59'))]
c13=pd.concat((c10,c11))
acts=sorted(list(set(c13['Activity'])))
act1=pd.Series(acts)
tot=[c13[c13['Activity']==j]['Duration'].sum() for j in act1]
tot1=pd.Series(tot)
tot2=pd.DataFrame({'Activity': act1,'Total Duration':tot1})
tot2 = tot2.sort_values(by='Total Duration',ascending=False)
tot2 = tot2.reset_index(drop=True)
display(tot2)
out1 = widgets.interactive_output(filter_data, {'date': date_wid})
out2 = widgets.interactive_output(total_df, {'date': date_wid})
ui = VBox([date_wid,HBox([out1,out2])])
return ui
def change_date_range(change):
data = _date_filter(app_state['data'],
change['new'],
timestamp_column=timestamp_column).dropna(
subset=nuts_ids_columns, how='all')
merged_dfs = [
merge_df(data=data,
nuts_shapes=nuts_shapes,
nuts_ids_column=nuts_ids_column,
color_column=color_column,
level=level_selector.value,
levels=app_state['nuts_levels'])
for nuts_ids_column in nuts_ids_columns
]
app_state['vmax'] = np.max(
[df[color_column].max() for df in merged_dfs])
interactive_output(
plot_cbar, dict(name=cmap_selector, logarithmic=logarithmic_cbox))
m.layers = [l for l in m.layers if type(l) != ipyleaflet.LayerGroup]
for merged_df, nuts_ids_column in zip(merged_dfs, nuts_ids_columns):
table_columns = [
'_timestamp', 'text_translated', 'num_persons', 'mode',
*[col for col in nuts_ids_columns if col != nuts_ids_column]
]
layer = get_shapes_heatmap(data=merged_df,
nuts_ids_column=nuts_ids_column,
color_column=color_column,
info_widget_html=info_widget,
vmin=app_state['vmin'],
vmax=app_state['vmax'],
full_data=app_state['full_data'],
time_hist=time_hist,
date_limits=change['new'],
tweets_table=tweets_table,
cmap=app_state['cmap'],
table_columns=table_columns,
logarithmic=app_state['logarithmic'])
m.add_layer(layer)
if 'full_groups' not in app_state:
app_state['full_groups'] = [
l.layers for l in m.layers if type(l) is ipyleaflet.LayerGroup
]
cbar_widget.children = [
interactive_output(
plot_cbar,
dict(name=cmap_selector, logarithmic=logarithmic_cbox))
]
def __get_select_columns(self, table_text):
columns = self.__get_column_list(table_text)
self.select_multiple_columns = widgets.SelectMultiple(
options=columns,
description='SELECT ',
disabled=False,
layout={
'left': '-30px',
'width': '770px'
})
#update the query on select_multiple chnage
widgets.interactive_output(
self.__update_on_multiple,
{'select_multiple': self.select_multiple_columns})
display(widgets.HBox([self.select_multiple_columns]))
def initialise_notebook(self):
''' initialises the checkboxes for the jupyter notebook
'''
style = {'description_width': 'initial'}
layout = Layout(flex='2 1 auto', width='auto')
a = widgets.Text(placeholder='/path/to/simulation/data',
description='Simulation Base Directory:',
disabled=False,
layout=layout,
style=style)
b = widgets.Text(placeholder='/path/to/output/directory',
description='Output Directory:',
disabled=False,
layout=layout,
style=style)
c = widgets.Text(placeholder='Free_energy_summary.csv',
description='Free energy file:',
disabled=False,
layout=layout,
style=style)
d = widgets.BoundedIntText(value=0,
min=0,
max=1000000,
step=1,
description='Number of frames to discard',
layout=layout,
style=style)
e = widgets.Checkbox(False,
description='Plot Overlap matrices',
layout=layout,
style=style)
f = widgets.Checkbox(
False,
description='Subsample data according to statistical inefficiency',
layout=layout,
style=style)
g = widgets.Checkbox(False,
description='Generate Network analysis notebook',
layout=layout,
style=style)
ui = widgets.VBox([a, b, c, d, e, f, g],
layout=Layout(display='flex',
flex_flow='column',
align_items='stretch',
border='solid',
width='100%'))
def _func(a, b, c, d, e, f, g):
print((a, b, c, d, e, f, g))
self._out = widgets.interactive_output(_func, {
'a': a,
'b': b,
'c': c,
'd': d,
'e': e,
'f': f,
'g': g
})
return ui
def __init__(self, spec, display_widget=True, display_value=False):
self.columns = [
widgets.Checkbox(value=False,
description=column['name'],
disabled=False) for column in spec
]
self.rows_box = widgets.VBox(self.columns)
self.value = widgets.ValueWidget()
def update_output(*args):
self.value.value = self.selected_columns
for column in self.columns:
column.observe(update_output, 'value')
self.widgets = [widgets.Label('columns'), self.rows_box]
update_output()
if display_value and display_widget:
def display_value(columns):
print(columns)
self.output = widgets.interactive_output(display_value,
{'columns': self.value})
self.widgets.append(self.output)
self.widget_container = widgets.VBox(self.widgets)
if display_widget:
display(self.widget_container)
def get_linreg_interactive(input_data):
df = input_data.copy()
m = widgets.FloatSlider(description='m', min=0, max=5, step=0.25)
c = widgets.FloatSlider(description='c', min=-2, max=2, step=0.25)
e = widgets.FloatText(description='error')
def f(m, c):
fig = plt.figure(figsize=(10, 6))
x = np.linspace(-10, 10, num=100)
err = np.sum((df['y'] - (m * df['X'] + c))**2)
e.value = err
plt.plot(x, m * x + c)
plt.scatter(df['X'], df['y'], c='r')
plt.ylim(0, 4)
plt.xlim(0, 1)
plt.show()
out = widgets.VBox([
widgets.VBox([m, c, e]),
widgets.interactive_output(f, {
'm': m,
'c': c
})
])
return out
def lpm_models():
a0, b0, c0 = [2.2e-3, 1.1e-1, 6.8e-3]
dlog = 0.1
a = FloatLogSlider(value=a0,
base=10,
description=r'$a$',
min=np.log10(a0) - dlog,
max=np.log10(a0) + dlog,
step=dlog / 10,
continuous_update=False)
b = FloatLogSlider(value=b0,
base=10,
description=r'$b$',
min=np.log10(b0) - dlog,
max=np.log10(b0) + dlog,
step=dlog / 10,
continuous_update=False)
dlog *= 5
c = FloatLogSlider(value=c0,
base=10,
description=r'$c$',
min=np.log10(c0) - dlog,
max=np.log10(c0) + dlog,
step=dlog / 10,
continuous_update=False)
io = interactive_output(plot_lpm_models, {'a': a, 'b': b, 'c': c})
return VBox([HBox([a, b, c]), io])
def show():
max_ = max_iter * n_scenes
i = IntSlider(value=0, min=0, max=max_, continuous_update=False)
play = Play(interval=2000, value=0, min=0, max=max_, step=1)
jslink((play, 'value'), (i, 'value'))
output = interactive_output(plot, dict(i=i))
display(play, output)
def Suspension():
"""
Suspension function to be called from notebook.
"""
c_sldr = widgets.FloatSlider(3,
min=0,
max=3,
step=0.1,
description='c',
continuous_update=False)
m_sldr = widgets.FloatSlider(1,
min=0.1,
max=3,
step=0.1,
description='m',
continuous_update=False)
k_sldr = widgets.FloatSlider(1,
min=0.1,
max=3,
step=0.1,
description='k',
continuous_update=False)
return (widgets.VBox([
widgets.HBox([c_sldr, m_sldr, k_sldr]),
widgets.interactive_output(suspensionMain, {
'c': c_sldr,
'm': m_sldr,
'k': k_sldr
})
]))
def show():
max_depth = 5
depth = IntSlider(value=1, min=1, max=max_depth, continuous_update=False)
play = Play(interval=1000, value=1, min=1, max=max_depth, step=1)
jslink((play, 'value'), (depth, 'value'))
output = interactive_output(plot, dict(depth=depth))
display(play, output)
def structural():
var = 0.1
mtrue, ctrue = [2, 3]
cmin, c0, cmax = [2.55, 3.05, 3.55]
mmin, m0, mmax = [1.3, 2.1, 2.9]
#p = Posterior(cmin=cmin,cmax=cmax,Nc=31,mmin=mmin,mmax=mmax,Nm=31,ctrue=ctrue,mtrue=mtrue,var=var)
p = UberPosterior(N=41, var=var)
zoom = Checkbox(value=False, description='zoom')
options = Dropdown(options={
'power-law': 1,
'logarithmic': 2,
'sinusoidal': 3
},
value=2,
description='alternative model')
zoom = Checkbox(value=False, description='zoom')
xf = FloatSlider(value=3,
description=r'$x_f$',
min=2,
max=5,
step=0.5,
continuous_update=False)
io = interactive_output(plot_structural, {
'zoom': zoom,
'option': options,
'xf': xf,
'p': fixed(p)
})
return VBox([HBox([zoom, options, xf]), io])
def posterior(Nm, Nc):
mtrue, ctrue = [2, 3]
cmin, c0, cmax = [2.55, 3.05, 3.55]
mmin, m0, mmax = [1.3, 2.1, 2.9]
m = FloatSlider(value=m0,
description=r'$m$',
min=mmin,
max=mmax,
step=(mmax - mmin) / Nm,
continuous_update=False)
c = FloatSlider(value=c0,
description=r'$c$',
min=cmin,
max=cmax,
step=(cmax - cmin) / Nc,
continuous_update=False)
p = Posterior(cmin=cmin,
cmax=cmax,
Nc=Nc,
mmin=mmin,
mmax=mmax,
Nm=Nm,
ctrue=ctrue,
mtrue=mtrue,
var=0.1)
io = interactive_output(plot_posterior, {'m': m, 'c': c, 'p': fixed(p)})
return VBox([HBox([m, c]), io])
def display_rel_change(self, minus_days=365):
start = pd.Timestamp.today() - pd.DateOffset(days=minus_days)
ia_start = widgets.DatePicker(description='Start Date', value=start)
ia_height = widgets.IntSlider(value=700,
min=200,
max=1000,
step=100,
description='Height:',
disabled=False,
continuous_update=False,
orientation='horizontal',
readout=True,
readout_format='d')
ia_decimals = widgets.IntSlider(value=1,
min=0,
max=3,
step=1,
description='Decimals:',
disabled=False,
continuous_update=False,
orientation='horizontal',
readout=True,
readout_format='d')
controls = {
'start': ia_start,
'height': ia_height,
'decimals': ia_decimals
}
ui = widgets.HBox([ia_start, ia_height, ia_decimals])
out = widgets.interactive_output(self.scatter_rel_change, controls)
display(ui, out)
def idisplay(array: np.ndarray, **kwargs) -> None:
# inspired by https://github.com/fepegar/miccai-educational-challenge-2019/blob/master/visualization.py
def get_widget(size, description):
widget = widgets.IntSlider(
min=0,
max=size - 1,
step=1,
value=size // 2,
continuous_update=False,
description=description,
)
return widget
shape = array.shape[:3]
names = 'Sagittal', 'Coronal', 'Axial'
widget_sag, widget_cor, widget_axi = [
get_widget(s, n) for (s, n) in zip(shape, names)
]
ui = widgets.HBox([widget_sag, widget_cor, widget_axi])
args_dict = {
'img_data': fixed(array),
'idx_x': widget_sag,
'idx_y': widget_cor,
'idx_z': widget_axi,
'verbose': fixed(False),
'return_figure': fixed(True)
}
kwargs = {key: fixed(value) for (key, value) in kwargs.items()}
args_dict.update(kwargs)
out = widgets.interactive_output(display, args_dict)
IPython.display.display(ui, out)
def jointplot(self, df) -> None:
self._set_df(df)
print(colored("\nJoint Plot:\n", "red", attrs=["bold"]))
col = df.columns
column_dropdown1 = self.widget.dropdown(
col, col[0], "X-axis:")
column_dropdown2 = self.widget.dropdown(
col, col[0], "Y-axis:")
kind = ["scatter", "kde", "hist", "hex", "reg", "resid"]
kind_dropdown = self.widget.dropdown(
kind, kind[0], "Kind:")
hue_dropdown = self.widget.dropdown(
col, None, "Hue:")
items = [column_dropdown1, column_dropdown2,
kind_dropdown, hue_dropdown]
joint_plot_ui = widgets.HBox(items)
output = widgets.interactive_output(self._plot_joinplot, {
'x': column_dropdown1, 'y': column_dropdown2, 'kind': kind_dropdown, "hue": hue_dropdown})
display(joint_plot_ui, output)
