height=10)
stats_title_s = PreText(text='Selected Data of current setting',
width=600,
height=5)
stats_title_a = PreText(text='All Data of current setting',
width=600,
height=5)
stats_title_n = PreText(text="Default Stress Level", width=600, height=5)
stats_select = PreText(text='', width=600)
stats_all = PreText(text='', width=600)
stats_normal = PreText(text='', width=600)
# original ticker (work)
ticker1 = Select(title="user",
value='userB',
options=DEFAULT_TICKERS_1,
width=100)
ticker2 = Select(title="role",
value='driver',
options=DEFAULT_TICKERS_2,
width=100)
ticker3 = Select(title="expiment type",
value='crazy',
options=DEFAULT_TICKERS_3,
width=100)
# dummy ticker
ticker_d0 = Select(title="Loose Ball",
value='LooseBall_id_1',
options=DUMMY_TICKERS_0,
width=260)
def sw_industry_analysis():
def nix(val, lst):
return [x for x in lst if x != val]
def get_data(ticker_1, ticker_2, start='20180101', end=datetime.today().date()):
df = get_price([ticker_1, ticker_2], start, end, fields='close')
df['t1_returns'] = np.log(df[ticker_1]).diff()
df['t2_returns'] = np.log(df[ticker_2]).diff()
return df.dropna().reset_index()
def get_hhist_data(data):
hhist, hedges = np.histogram(data['t1_returns'], bins=20)
hzeros = np.zeros_like(hhist)
hhist_data = {'left': hedges[:-1], 'right': hedges[1:], 'bottom': hzeros,
'top': hhist, 'top_1': hzeros, 'top_2': hzeros}
return hhist_data
def get_vhist_data(data):
vhist, vedges = np.histogram(data['t2_returns'], bins=20)
vzeros = np.zeros_like(vhist)
vhist_data = {'left': vzeros, 'right': vhist, 'bottom': vedges[:-1],
'top': vedges[1:], 'right_1': vzeros, 'right_2': vzeros}
return vhist_data
def ticker1_change(attr, old, new):
ticker_2.options = nix(new, DEFAULT_TICKERS)
update()
def ticker2_change(attr, old, new):
ticker_1.options = nix(new, DEFAULT_TICKERS)
update()
def update():
global df
ticker_1_name, ticker_2_name = SHENWAN_INDUSTRY_MAP_[ticker_1.value], SHENWAN_INDUSTRY_MAP_[ticker_2.value]
df = get_data(ticker_1_name, ticker_2_name)
source.data.update(dict(x=df['t1_returns'], y=df['t2_returns'], x_p=df[ticker_1_name],
y_p=df[ticker_2_name], date=df['date']))
hhist_data_dict = get_hhist_data(df)
source_hhist.data.update(hhist_data_dict)
hmax = max(source_hhist.data['top']) * 1.1
ph.y_range.update(start=-hmax, end=hmax)
print('ph.y_range', ph.y_range.end)
vhist_data_dict = get_vhist_data(df)
source_vhist.data.update(vhist_data_dict)
vmax = max(source_vhist.data['right']) * 1.1
pv.x_range.update(start=vmax, end=-vmax)
print('pv.x_range', pv.x_range.end)
print(20 * '=')
update_stats(df, ticker_1_name, ticker_2_name)
corr.title.text = "{} vs. {}".format(ticker_1.value, ticker_2.value)
ts1.title.text = ticker_1.value
ts2.title.text = ticker_2.value
def udpate_selection(attr, old, new):
inds = new # 选定的数据对应的索引
length = len(df)
if 0 < len(inds) < length:
neg_inds = [s for s in range(length) if s not in inds] # 未选定数据点的对应索引
_, hedges = np.histogram(df['t1_returns'], bins=20)
_, vedges = np.histogram(df['t2_returns'], bins=20)
new_hhist_df = df['t1_returns']
new_vhist_df = df['t2_returns']
hhist1, _ = np.histogram(new_hhist_df.iloc[inds], bins=hedges)
hhist2, _ = np.histogram(new_hhist_df.iloc[neg_inds], bins=hedges)
vhist1, _ = np.histogram(new_vhist_df.iloc[inds], bins=vedges)
vhist2, _ = np.histogram(new_vhist_df.iloc[neg_inds], bins=vedges)
source_hhist.patch({'top_1': [(slice(None), hhist1)], 'top_2': [(slice(None), -hhist2)]})
source_vhist.patch({'right_1': [(slice(None), vhist1)], 'right_2': [(slice(None), -vhist2)]})
def update_stats(data, t1, t2):
stats_indicator = data[[t1, t2, 't1_returns', 't2_returns']].describe()
ticker_1_name, ticker_2_name = ticker_1.value, ticker_2.value
stats_indicator.columns = [ticker_1_name, ticker_2_name, ticker_1_name + '收益率', ticker_2_name + '收益率']
stats.text = str(stats_indicator)
# Set Up Widgets
stats = PreText(text='', width=700)
ticker_1 = Select(value='非银金融', options=nix('食品饮料', DEFAULT_TICKERS))
ticker_2 = Select(value='食品饮料', options=nix('非银金融', DEFAULT_TICKERS))
# Callback
ticker_1.on_change('value', ticker1_change)
ticker_2.on_change('value', ticker2_change)
# Construct DataSource
source = ColumnDataSource(data=dict(x=[], y=[], x_p=[], y_p=[], date=[]))
source_hhist = ColumnDataSource(data=dict(left=[], right=[], bottom=[], top=[], top_1=[], top_2=[]))
source_vhist = ColumnDataSource(data=dict(left=[], right=[], bottom=[], top=[], right_1=[], right_2=[]))
# 收益率散点图
corr = figure(plot_width=500, plot_height=500, tools=TOOLS)
r = corr.scatter(x='x', y='y', size=2, source=source, selection_color='orange', alpha=0.6,
nonselection_alpha=0.1, selection_alpha=0.4)
# 添加横轴直方图
hmax = 40
ph = figure(toolbar_location=None, plot_width=corr.plot_width, plot_height=200, y_range=(-hmax, hmax),
min_border=10, min_border_left=None, y_axis_location='left', x_axis_location='above')
ph.quad(bottom='bottom', top='top', left='left', right='right', color='white', line_color="#3A5785",
source=source_hhist)
ph.quad(bottom='bottom', top='top_1', left='left', right='right', alpha=0.5, source=source_hhist, **LINE_ARGS)
ph.quad(bottom='bottom', top='top_2', left='left', right='right', alpha=0.1, source=source_hhist, **LINE_ARGS)
ph.xgrid.grid_line_color = None
ph.yaxis.major_label_orientation = np.pi / 4
ph.background_fill_color = '#fafafa'
# 添加纵轴直方图
vmax = 40
pv = figure(toolbar_location=None, plot_height=corr.plot_height, plot_width=200, x_range=(vmax, -vmax),
min_border=10, min_border_left=None, y_axis_location='left')
pv.quad(bottom='bottom', top='top', left='left', right='right', color='white', line_color="#3A5785",
source=source_vhist)
pv.quad(bottom='bottom', top='top', left='left', right='right_1', alpha=0.5, source=source_vhist, **LINE_ARGS)
pv.quad(bottom='bottom', top='top', left='left', right='right_2', alpha=0.1, source=source_vhist, **LINE_ARGS)
# 股价时间序列图
ts1 = figure(plot_width=900, plot_height=200, tools=TOOLS, x_axis_type='datetime', active_drag='box_select',
toolbar_location='above')
ts1.line('date', 'x_p', source=source)
ts1.circle('date', 'x_p', size=1, source=source, color=None, selection_color='orange')
ts2 = figure(plot_width=ts1.plot_width, plot_height=ts1.plot_height, tools=TOOLS, x_axis_type='datetime',
active_drag='box_select', toolbar_location='above')
ts2.x_range = ts1.x_range
ts2.line('date', 'y_p', source=source)
ts2.circle('date', 'y_p', size=1, source=source, color=None, selection_color='orange')
# 初始化数据
update()
r.data_source.selected.on_change('indices', udpate_selection)
widgets = column(ticker_1, ticker_2, widgetbox(stats))
layout_1 = column(row(Spacer(width=200, height=200), ph), row(pv, corr, widgets))
layout_2 = column(layout_1, ts1, ts2)
tab = Panel(child=layout_2, title='IndustryAnalysis')
return tab
def add_controllers(self):
titles = {'npeople': 'Number of people',
'sensorinterval': 'Interval',
'sensortpr': 'True positive rate',
'sensorexfp': 'Expected num of FP',
'sensorrange': 'Sensor range',
'sensorsnum': 'Fleet size',
'sensorspeed': 'Fleet speed'}
idx0 = 1
stacked = []
#Create a controller for the scaling
def on_scaling_changed(_, _old, _new):
self.scaling = _new
self.update_plot()
self.scalingwidget = Select(title='Scaling', value='linear',
options=['linear', 'log'])
self.scalingwidget.on_change('value', on_scaling_changed)
stacked.append(self.scalingwidget)
# Create a controller for each param
for k in titles.keys():
def on_radio_changed(attr, old, new, kk):
if self.blocked: return
newvalue = self.config[kk][new-1] if new != FIXEDIDX else -1
print('Changed ' + str(kk) + ' to ' + str(newvalue))
self.currparams[kk] = newvalue
if new == FIXEDIDX:
self.blocked = True
for param in self.contr.keys():
if param == kk or self.contr[param].active != FIXEDIDX:
continue
self.contr[param].active = 1
self.currparams[param] = self.config[param][0]
self.var = kk
varyingparam = False
for kkk, vvv in self.currparams.items():
if vvv == -1:
varyingparam = True
break
if not varyingparam: self.var = None
self.update_plot()
if self.blocked: self.blocked = False
my_radio_changed = partial(on_radio_changed, kk=k)
params = ['varying'] + list(map(str, self.config[k]))
buttonisactive = FIXEDIDX if self.var == k else idx0
self.contr[k] = RadioButtonGroup(labels=params, active=buttonisactive)
self.contr[k].on_change('active', my_radio_changed)
self.currparams[k] = params[idx0]
r = Row(widgetbox(Div(text='{}:'.format(titles[k]))),
self.contr[k])
stacked.append(r)
self.currparams[self.var] = -1
adjwidget = Column(*stacked)
self.guirow.children[0] = adjwidget
from simuojo_module import ic50_simu, DR_5PL, Kd_simu, ric50_simu, ri50_coop_simu
from bokeh.io import curdoc
from bokeh.layouts import row, layout
from bokeh.models.widgets import Div, Select
import os
#
# from dotenv import load_dotenv
#
# basedir = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir))
#
# load_dotenv(os.path.join(basedir, '.env'))
simu_sele = Select(title='Select a simulation model',
value='Select a model',
options=[
'Select a model', 'kd simulation', 'ic_50 simulation',
'ric_50 simulation', 'ric_50_coop simulation',
'Dose-Response 5 Para Logistic'
])
model_display = Div(text="""<h1>Welcome to Simuojo!</h1>""",
width=600,
height=75)
def simu_sele_cb(attr, old, new):
if new == 'kd simulation':
kd_layout = Kd_simu().layout
temp = layout([model_display, simu_sele], *kd_layout)
select_layout.children = temp.children
model_display.text = """
def __init__(self, model, resolution=50, doc=None):
"""
Initialize parameters.
Parameters
----------
model : MetaModelComponent
Reference to meta model component
resolution : int
Value used to calculate the size of contour plot meshgrid
doc : Document
The bokeh document to build.
"""
self.prob = Problem()
self.resolution = resolution
logging.getLogger("bokeh").setLevel(logging.ERROR)
# If the surrogate model coming in is structured
if isinstance(model, MetaModelUnStructuredComp):
self.is_structured_meta_model = False
# Create list of input names, check if it has more than one input, then create list
# of outputs
self.input_names = [
name[0] for name in model._surrogate_input_names
]
if len(self.input_names) < 2:
raise ValueError('Must have more than one input value')
self.output_names = [
name[0] for name in model._surrogate_output_names
]
# Create reference for untructured component
self.meta_model = MetaModelUnStructuredComp(
default_surrogate=model.options['default_surrogate'])
# If the surrogate model coming in is unstructured
elif isinstance(model, MetaModelStructuredComp):
self.is_structured_meta_model = True
self.input_names = [name for name in model._var_rel_names['input']]
if len(self.input_names) < 2:
raise ValueError('Must have more than one input value')
self.output_names = [
name for name in model._var_rel_names['output']
]
self.meta_model = MetaModelStructuredComp(
distributed=model.options['distributed'],
extrapolate=model.options['extrapolate'],
method=model.options['method'],
training_data_gradients=model.
options['training_data_gradients'],
vec_size=1)
# Pair input list names with their respective data
self.training_inputs = {}
self._setup_empty_prob_comp(model)
# Setup dropdown menus for x/y inputs and the output value
self.x_input_select = Select(title="X Input:",
value=[x for x in self.input_names][0],
options=[x for x in self.input_names])
self.x_input_select.on_change('value', self._x_input_update)
self.y_input_select = Select(title="Y Input:",
value=[x for x in self.input_names][1],
options=[x for x in self.input_names])
self.y_input_select.on_change('value', self._y_input_update)
self.output_select = Select(title="Output:",
value=[x for x in self.output_names][0],
options=[x for x in self.output_names])
self.output_select.on_change('value', self._output_value_update)
# Create sliders for each input
self.slider_dict = {}
self.predict_inputs = {}
for title, values in self.training_inputs.items():
slider_data = np.linspace(min(values), max(values),
self.resolution)
self.predict_inputs[title] = slider_data
# Calculates the distance between slider ticks
slider_step = slider_data[1] - slider_data[0]
slider_object = Slider(start=min(values),
end=max(values),
value=min(values),
step=slider_step,
title=str(title))
self.slider_dict[title] = slider_object
self._slider_attrs()
# Length of inputs and outputs
self.num_inputs = len(self.input_names)
self.num_outputs = len(self.output_names)
# Precalculate the problem bounds.
limits = np.array([[min(value), max(value)]
for value in self.training_inputs.values()])
self.limit_range = limits[:, 1] - limits[:, 0]
# Positional indicies
self.x_index = 0
self.y_index = 1
self.output_variable = self.output_names.index(
self.output_select.value)
# Data sources are filled with initial values
# Slider Column Data Source
self.slider_source = ColumnDataSource(data=self.predict_inputs)
# Contour plot Column Data Source
self.contour_plot_source = ColumnDataSource(data=dict(
z=np.random.rand(self.resolution, self.resolution)))
self.contour_training_data_source = ColumnDataSource(data=dict(
x=np.repeat(0, self.resolution), y=np.repeat(0, self.resolution)))
# Bottom plot Column Data Source
self.bottom_plot_source = ColumnDataSource(data=dict(
x=np.repeat(0, self.resolution), y=np.repeat(0, self.resolution)))
self.bottom_plot_scatter_source = ColumnDataSource(
data=dict(bot_slice_x=np.repeat(0, self.resolution),
bot_slice_y=np.repeat(0, self.resolution)))
# Right plot Column Data Source
self.right_plot_source = ColumnDataSource(data=dict(
x=np.repeat(0, self.resolution), y=np.repeat(0, self.resolution)))
self.right_plot_scatter_source = ColumnDataSource(
data=dict(right_slice_x=np.repeat(0, self.resolution),
right_slice_y=np.repeat(0, self.resolution)))
# Text input to change the distance of reach when searching for nearest data points
self.scatter_distance = TextInput(value="0.1",
title="Scatter Distance")
self.scatter_distance.on_change('value', self._scatter_input)
self.dist_range = float(self.scatter_distance.value)
# Grouping all of the sliders and dropdowns into one column
sliders = [value for value in self.slider_dict.values()]
sliders.extend([
self.x_input_select, self.y_input_select, self.output_select,
self.scatter_distance
])
self.sliders_and_selects = row(column(*sliders))
# Layout creation
self.doc_layout = row(self._contour_data(), self._right_plot(),
self.sliders_and_selects)
self.doc_layout2 = row(self._bottom_plot())
if doc is None:
doc = curdoc()
doc.add_root(self.doc_layout)
doc.add_root(self.doc_layout2)
doc.title = 'Meta Model Visualization'
button_type="success",
width=120)
file_selection_button.on_click(load_files_group)
files_selector_spacer = Spacer(width=10)
group_selection_button = Button(label="Select Directory",
button_type="primary",
width=140)
group_selection_button.on_click(load_directory_group)
unload_file_button = Button(label="Unload", button_type="danger", width=50)
unload_file_button.on_click(unload_file)
# files selection box
files_selector = Select(title="Files:", options=[])
files_selector.on_change('value', change_data_selector)
# data selection box
data_selector = MultiSelect(title="Data:", options=[], size=12)
data_selector.on_change('value', select_data)
# x axis selection box
x_axis_selector_title = Div(text="""X Axis:""")
x_axis_selector = RadioButtonGroup(labels=x_axis_options, active=0)
x_axis_selector.on_click(change_x_axis)
# toggle second axis button
toggle_second_axis_button = Button(label="Toggle Second Axis",
button_type="success")
toggle_second_axis_button.on_click(toggle_second_axis)
def single_pie_tab(df_means, df_stdev, Time, Treatments, number_cmpds_run):
len_t = len(Treatments)
colors = [
"firebrick", "navy", 'green', 'orange', 'violet', 'lawngreen',
'lightgreen', 'yellow', 'olive', 'red', 'grey', 'skyblue', 'indigo',
'slategray', 'hotpink', 'peachpuff', 'powderblue'
]
df_means = df_means.reindex(index=order_by_index(
df_means.index, index_natsorted(df_means[Time[0]])))
cmpd_options = cmpd_options_func(df_means, len_t + 1, number_cmpds_run)
time_vals = df_means[Time[0]].drop_duplicates().tolist()
if len(Treatments) == 4:
df_means[Treatments[0]] = df_means[Treatments[0]].astype('str')
df_means[Treatments[1]] = df_means[Treatments[1]].astype('str')
df_means[Treatments[2]] = df_means[Treatments[2]].astype('str')
df_means[Treatments[3]] = df_means[Treatments[3]].astype('str')
tm0_vals = df_means[Treatments[0]].drop_duplicates().tolist()
tm1_vals = df_means[Treatments[1]].drop_duplicates().tolist()
tm2_vals = df_means[Treatments[2]].drop_duplicates().tolist()
tm3_vals = df_means[Treatments[3]].drop_duplicates().tolist()
df_for_pie = df_means.loc[(df_means[Time[0]] == time_vals[0])
& (df_means[Treatments[0]] == tm0_vals[0]) &
(df_means[Treatments[1]] == tm1_vals[0]) &
(df_means[Treatments[2]] == tm2_vals[0]) &
(df_means[Treatments[3]] == tm3_vals[0])]
elif len(Treatments) == 3:
df_means[Treatments[0]] = df_means[Treatments[0]].astype('str')
df_means[Treatments[1]] = df_means[Treatments[1]].astype('str')
df_means[Treatments[2]] = df_means[Treatments[2]].astype('str')
tm0_vals = df_means[Treatments[0]].drop_duplicates().tolist()
tm1_vals = df_means[Treatments[1]].drop_duplicates().tolist()
tm2_vals = df_means[Treatments[2]].drop_duplicates().tolist()
df_for_pie = df_means.loc[(df_means[Time[0]] == time_vals[0])
& (df_means[Treatments[0]] == tm0_vals[0]) &
(df_means[Treatments[1]] == tm1_vals[0]) &
(df_means[Treatments[2]] == tm2_vals[0])]
elif len(Treatments) == 2:
df_means[Treatments[0]] = df_means[Treatments[0]].astype('str')
df_means[Treatments[1]] = df_means[Treatments[1]].astype('str')
tm0_vals = df_means[Treatments[0]].drop_duplicates().tolist()
tm1_vals = df_means[Treatments[1]].drop_duplicates().tolist()
df_for_pie = df_means.loc[(df_means[Time[0]] == time_vals[0])
& (df_means[Treatments[0]] == tm0_vals[0]) &
(df_means[Treatments[1]] == tm1_vals[0])]
elif len(Treatments) == 1:
df_means[Treatments[0]] = df_means[Treatments[0]].astype('str')
tm0_vals = df_means[Treatments[0]].drop_duplicates().tolist()
df_for_pie = df_means.loc[(df_means[Time[0]] == time_vals[0])
& (df_means[Treatments[0]] == tm0_vals[0])]
df_means = df_means.replace(float('nan'), 0)
def_cmpds = []
for i in range(5):
def_cmpds.append(df_means.columns[len_t + 1 + i])
len_cmpds = len(def_cmpds)
df_pie_values = df_for_pie[def_cmpds]
pie_vals = list(df_pie_values.values.flatten())
pie_fracs = [x / sum(pie_vals) for x in pie_vals]
percents = [0]
per_labels = []
for f in range(0, len(pie_fracs)):
ff = percents[f] + pie_fracs[f]
percents.append(ff)
per_labels.append(df_means.columns[len_t + 1 + f] + ':' +
str("{0:0.1f}".format(100.0 * pie_fracs[f])))
ss = [per * 2 * pi for per in percents[:-1]]
ee = [per * 2 * pi for per in percents[1:]]
mid = []
for pp in range(len(ss)):
mid.append(.5 * ss[pp] + .5 * ee[pp])
cc = colors[0:len_cmpds]
source = ColumnDataSource(data=dict(starts=ss, ends=ee, color=cc))
x_label, y_label = circ(.5, mid)
p_label_data = ColumnDataSource({
'x_label': x_label,
'y_label': y_label,
'p_labels': per_labels
})
p = figure(match_aspect=True, plot_height=1000, plot_width=1000)
x_vals, y_vals = circ(1)
p.line(x_vals, y_vals, line_width=5, color='black')
p.wedge(x=0,
y=0,
radius=1,
start_angle='starts',
end_angle='ends',
color='color',
source=source)
p_labels = LabelSet(x="x_label",
y="y_label",
text="p_labels",
source=p_label_data,
text_color='black')
p.add_layout(p_labels)
#widget for pie charts
sel_t = Select(title="Choose a time:",
value=time_vals[0],
options=time_vals)
if len(Treatments) == 4:
select0 = Select(title=Treatments[0],
value=str(tm0_vals[0]),
options=tm0_vals)
select1 = Select(title=Treatments[1],
value=str(tm1_vals[0]),
options=tm1_vals)
select2 = Select(title=Treatments[2],
value=str(tm2_vals[0]),
options=tm2_vals)
select3 = Select(title=Treatments[3],
value=str(tm3_vals[0]),
options=tm3_vals)
elif len(Treatments) == 3:
select0 = Select(title=Treatments[0],
value=str(tm0_vals[0]),
options=tm0_vals)
select1 = Select(title=Treatments[1],
value=str(tm1_vals[0]),
options=tm1_vals)
select2 = Select(title=Treatments[2],
value=str(tm2_vals[0]),
options=tm2_vals)
elif len(Treatments) == 2:
select0 = Select(title=Treatments[0],
value=str(tm0_vals[0]),
options=tm0_vals)
select1 = Select(title=Treatments[1],
value=str(tm1_vals[0]),
options=tm1_vals)
elif len(Treatments) == 1:
select0 = Select(title=Treatments[0],
value=str(tm0_vals[0]),
options=tm0_vals)
checkbox_group = CheckboxGroup(labels=cmpd_options, active=[0, 1, 2, 3, 4])
def update_data(attrname, old, new):
if len(Treatments) == 4:
df_for_pie = df_means.loc[
(df_means[Time[0]] == sel_t.value)
& (df_means[Treatments[0]] == select0.value) &
(df_means[Treatments[1]] == select1.value) &
(df_means[Treatments[2]] == select2.value) &
(df_means[Treatments[3]] == select3.value)]
elif len(Treatments) == 3:
df_for_pie = df_means.loc[
(df_means[Time[0]] == sel_t.value)
& (df_means[Treatments[0]] == select0.value) &
(df_means[Treatments[1]] == select1.value) &
(df_means[Treatments[2]] == select2.value)]
elif len(Treatments) == 2:
df_for_pie = df_means.loc[
(df_means[Time[0]] == sel_t.value)
& (df_means[Treatments[0]] == select0.value) &
(df_means[Treatments[1]] == select1.value)]
elif len(Treatments) == 1:
df_for_pie = df_means.loc[(df_means[Time[0]] == sel_t.value) & (
df_means[Treatments[0]] == select0.value)]
compounds_in_pie = []
for i in checkbox_group.active:
compounds_in_pie.append(cmpd_options[i])
df_pie_values = df_for_pie[compounds_in_pie]
pie_vals = list(df_pie_values.values.flatten())
pie_fracs = [x / sum(pie_vals) for x in pie_vals]
percents = [0]
per_labels = []
for f in range(0, len(pie_fracs)):
ff = percents[f] + pie_fracs[f]
percents.append(ff)
per_labels.append(compounds_in_pie[f] + ':' +
str("{0:0.1f}".format(100.0 * pie_fracs[f])))
starts = [per * 2 * pi for per in percents[:-1]]
ends = [per * 2 * pi for per in percents[1:]]
if len(ends) == 0:
ends = [0] * len(compounds_in_pie)
starts = [0] * len(compounds_in_pie)
#per_labels=[0] * len(compounds_in_pie)
#per_labels=['{:.2f}'.format(x) for x in per_labels]
mid = []
for pp in range(len(starts)):
mid.append(.5 * starts[pp] + .5 * ends[pp])
pie_colors = colors[0:len(compounds_in_pie)]
x_label, y_label = circ(.5, mid)
result2_label = {
'x_label': x_label,
'y_label': y_label,
'p_labels': per_labels
}
result2 = {'starts': starts, 'ends': ends, 'color': pie_colors}
source.data = result2
p_label_data.data = result2_label
if len(Treatments) == 4:
for w in [sel_t, select0, select1, select2, select3]:
w.on_change('value', update_data)
elif len(Treatments) == 3:
for w in [sel_t, select0, select1, select2]:
w.on_change('value', update_data)
elif len(Treatments) == 2:
for w in [sel_t, select0, select1]:
w.on_change('value', update_data)
elif len(Treatments) == 1:
for w in [sel_t, select0]:
w.on_change('value', update_data)
checkbox_group.on_change('active', update_data)
## Set up the widgets for pie
if len(Treatments) == 4:
inputs1 = widgetbox(sel_t, select0, select1, select2, select3)
elif len(Treatments) == 3:
inputs1 = widgetbox(sel_t, select0, select1, select2)
elif len(Treatments) == 2:
inputs1 = widgetbox(sel_t, select0, select1)
elif len(Treatments) == 1:
inputs1 = widgetbox(sel_t, select0)
inputs2 = widgetbox(checkbox_group)
# Set up layouts and add to document
layout = row(column(inputs1), inputs2, p, width=1500)
tab = Panel(child=layout, title='Pie Charts')
return tab
def symbol_size(values):
""" Rescale given values to reasonable symbol sizes in the plot. """
max_size = 50.0
min_size = 5.0
# Rescale max.
slope = (max_size - min_size) / (values.max() - values.min())
return slope * (values - values.max()) + max_size
# Directory selection.
dirs = os.listdir(model.parent_dir)
dirs.sort()
directory_selection = Select(options=dirs, value=dirs[1])
directory_selection.on_change('value', directory_update)
# Init model first time.
model.frames = get_frames(directory_selection.value)
# Slider to select frame.
idx_selection_slider = Slider(start=model.idxs[0],
end=model.idxs[-1],
step=1.0,
value=model.idxs[0],
title="Select frame id")
idx_selection_slider.on_change('value', idx_slider_update)
# Spinner to select frame.
idx_selection_spinner = Spinner(low=model.idxs[0],
from src.clusterController import ClusterController
def getAllClusterSubset(allClusters, subsetsize):
clusters = allClusters[0:subsetsize]
return clusters
#cst_data = pd.read_csv(join(dirname(__file__), 'data', 'CTSData.csv'))
#cst_data = pd.read_csv(join(dirname(__file__), 'data', 'CTSData.csv')).dropna()
clustCont = ClusterController()
tab_perm = clustCont.tab
b1 = Button(label="Run")
s1 = Select(title="Option:", value="fd", options=["fd", "bar", "baz", "quux"])
controls = column(b1, s1)
src = ColumnDataSource(data={'x': [3, 5], 'y': [8, -1]})
columns = [
TableColumn(field="x", title="x"),
TableColumn(field="y", title="y"),
]
datatable = DataTable(
source=src,
columns=columns,
width=800,
height=300,
editable=False,
])
#add labels for glyphs
labels = LabelSet(x="average_grades",
y="exam_grades",
text="student_names",
x_offset=5,
y_offset=5,
source=source)
f.add_layout(labels)
#create glyphs
f.circle(x="average_grades", y="exam_grades", source=source, size=8)
#create function
def update_labels(attr, old, new):
labels.text = select.value
#create select widget
options = [("average_grades", "Average Grades"),
("exam_grades", "Exam Grades"), ("student_names", "Student Names")]
select = Select(title="Attribute", options=options)
select.on_change("value", update_labels)
#create layout and add to curdoc
lay_out = layout([[select]])
curdoc().add_root(f)
curdoc().add_root(lay_out)
def create(self):
self.oldData = dict(peaks=[], classes=[])
self.sources['table'] = ColumnDataSource(
dict(xStart=[],
xStop=[],
name=[],
classes=[],
j=[],
h=[],
integral=[],
peaks=[],
top=[],
bottom=[]))
columns = [
TableColumn(field="xStart",
title="start",
formatter=NumberFormatter(format="0.00")),
TableColumn(field="xStop",
title="stop",
formatter=NumberFormatter(format="0.00")),
TableColumn(field="name", title="Name"),
TableColumn(field="classes", title="Class"),
TableColumn(field="j", title="J"),
TableColumn(field="h",
title="H",
formatter=NumberFormatter(format="0")),
TableColumn(field="integral",
title="Integral",
formatter=NumberFormatter(format="0.00"))
]
self.dataTable = DataTable(source=self.sources['table'],
columns=columns,
reorderable=False,
width=500)
self.sources['table'].on_change(
'selected',
lambda attr, old, new: self.rowSelect(new['1d']['indices']))
self.sources['table'].on_change(
'data', lambda attr, old, new: self.dataChanged(new))
self.manual = CustomButton(
label="Multiplet Analysis",
button_type="primary",
width=250,
error="Please select area using the multiplet analysis tool.")
self.manual.on_click(self.manualMultipletAnalysis)
self.createTool()
self.title = Div(text="<strong>Edit Multiplet:</strong>", width=500)
self.classes = Select(title="Class:",
options=[
"m", "s", "d", "t", "q", "p", "h", "hept",
"dd", "ddd", "dt", "td", "ddt"
],
width=100,
disabled=True)
self.classes.on_change(
'value', lambda attr, old, new: self.manualChange('classes', new))
self.integral = TextInput(title="Integral:",
value="",
placeholder="Integral",
width=175,
disabled=True)
self.integral.on_change(
'value', lambda attr, old, new: self.changeIntegral(new))
self.j = TextInput(title='J-list:', value="", width=175, disabled=True)
self.j.on_change('value',
lambda attr, old, new: self.manualChange('j', new))
self.delete = Button(label="Delete Multiplet",
button_type="danger",
width=500,
disabled=True)
self.delete.on_click(self.deleteMultiplet)
self.reportTitle = Div(text="<strong>Multiplet Report:</strong>")
self.report = Paragraph(width=500)
def graph_tab(data):
def f(data, year, month):
recent = data[(data['year'] == year) & (data['month'] == month)]
recent_by_day = recent.groupby('day')
sales_by_year = recent_by_day['Sales'].agg(np.sum)
sales = [sales for sales in sales_by_year]
return sales
recent = data[(data['year'] == 2017) & (data['month'] == 12)]
group_by_day = recent.groupby('day')
x = group_by_day['Sales'].agg(np.sum)
sales = [sale for sale in x]
source = ColumnDataSource(data={
'days': [x for x in range(len(sales))],
'sales': sales
})
p = figure(plot_width=800,
plot_height=600,
title="Day wise Total Sales for a given Year and Month",
x_axis_label="Days of Month",
y_axis_label="Total Sales")
p.title.align = 'center'
p.title.text_font_size = '20pt'
p.title.text_font = 'serif'
# Axis titles
p.xaxis.axis_label_text_font_size = '14pt'
p.xaxis.axis_label_text_font_style = 'bold'
p.yaxis.axis_label_text_font_size = '14pt'
p.yaxis.axis_label_text_font_style = 'bold'
# Tick labels
p.xaxis.major_label_text_font_size = '12pt'
p.yaxis.major_label_text_font_size = '12pt'
p.line(x='days', y='sales', source=source, line_width=1.5)
p.circle(x='days', y='sales', source=source)
menu1 = Select(title="Year",
value="2017",
options=['2017', '2016', '2015', '2014'])
menu2 = Select(title="Month",
value="Dec",
options=[
'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug',
'Sep', 'Oct', 'Nov', 'Dec'
])
def callback(attr, old, new):
month_num = {
'Jan': 1,
'Feb': 2,
'Mar': 3,
'Apr': 4,
'May': 5,
'Jun': 6,
'Jul': 7,
'Aug': 8,
'Sep': 9,
'Oct': 10,
'Nov': 11,
'Dec': 12
}
year = int(menu1.value)
month = month_num[menu2.value]
source.data = {
'days': [x for x in range(1, 31)],
'sales': f(data, year, month)
}
menu1.on_change('value', callback)
menu2.on_change('value', callback)
controls = widgetbox(menu1, menu2)
layout = row(controls, p)
tab = Panel(child=layout, title='Total Sales')
return tab
#curdoc().add_root(layout)
# reference: https://bokeh.pydata.org/en/latest/docs/user_guide/interaction/widgets.html
# how to add "all" category into the selector
# reference: https://stackoverflow.com//questions/50603077/bokeh-select-widget-does-not-update-plot
category = []
category.append('All')
category.extend(df['CATEGORY'].unique().tolist())
# ===== optionally: =====
# category = []
# category.append('All')
# category.extend(df['CATEGORY'].unique().tolist())
# add the selector, options can be: category, name, locality, protocol, etc....
# reference: https://bokeh.pydata.org/en/latest/docs/user_guide/interaction/widgets.html
select_category = Select(title="Option:", value="All", options=category)
# ==================================================================
# Task2: define the datasource construction function
# ==================================================================
# input: dataframe, either the original one or the updated one after triggering the selector
# output: column data source, which will be used for plotting, in our case, will serve as the input for the draw_plot function
def datasource_construct(dfnew):
# sort dfnew based on "OBSERVATION DATE", then reset the index for sorted dfnew
dfnew.sort_values(by=['OBSERVATION_DATE']).reset_index(inplace=True)
def get_data(t1, t2):
df1 = load_ticker(t1)
df2 = load_ticker(t2)
data = pd.concat([df1, df2], axis=1)
data = data.dropna()
data['t1'] = data[t1]
data['t2'] = data[t2]
data['t1_returns'] = data[t1 + '_returns']
data['t2_returns'] = data[t2 + '_returns']
return data
# set up widgets
stats = PreText(text='', width=500)
ticker1 = Select(value='AAPL', options=nix('GOOG', DEFAULT_TICKERS))
ticker2 = Select(value='GOOG', options=nix('AAPL', DEFAULT_TICKERS))
# set up plots
source = ColumnDataSource(
data=dict(date=[], t1=[], t2=[], t1_returns=[], t2_returns=[]))
source_static = ColumnDataSource(
data=dict(date=[], t1=[], t2=[], t1_returns=[], t2_returns=[]))
tools = 'pan,wheel_zoom,xbox_select,reset'
corr = figure(plot_width=350,
plot_height=350,
tools='pan,wheel_zoom,box_select,reset')
corr.circle('t1_returns',
't2_returns',
NewOrder = {'type': 'NewOrder', 'clientOrderId': str(clientOrderId), 'symbol': symbol , 'buySell': OrderType, 'qty': qty}
with SocketIO(server) as socketIO:
socketIO.emit('submitOrder', NewOrder)
socketIO.on('onOrderMessage', order_response)
socketIO.wait()
buyButton = Button(label="BUY", button_type="success")
buyButton.on_click(buyThreadFunc)
sellButton = Button(label="SELL", button_type="warning")
sellButton.on_click(sellThreadFunc)
select = Select(title="Ticker:", value=stocks_list[0], options=stocks_list)
select.on_change("value", ticker_handler)
quantity_input = TextInput(value="100", title="quantity:")
quantity_input.on_change("value", quantity_handler)
if currentPNL == 0 :
PNLbutton = Button(label="PNL : " + str(currentPNL), button_type="warning")
elif currentPNL >0 :
PNLbutton = Button(label="PNL : " + str(currentPNL), button_type="success")
else:
PNLbutton = Button(label="PNL : " + str(currentPNL), button_type="danger")
disp_buttons = dict(AAPL = Button(label= 'AAPL', button_type = "success"),
def bokeh_summary_plot(df, savepath=None):
"""Summary plot"""
from bokeh.plotting import figure
from bokeh.layouts import column
from bokeh.models import ColumnDataSource, Range1d, HoverTool, TapTool, CustomJS, OpenURL
TOOLS = "pan,wheel_zoom,hover,tap,reset,save"
colors = get_bokeh_colors()
df = df.rename(columns={'level_0': 'predictor'})
df['color'] = [colors[x] for x in df['predictor']]
p = figure(title="Summary", tools=TOOLS, width=500, height=500)
p.xaxis.axis_label = 'binder_density'
p.yaxis.axis_label = 'binders'
#make metric for point sizes
#df['point_size'] = df.binder_density
source = ColumnDataSource(data=df)
p.circle(x='binder_density',
y='binders',
line_color='black',
fill_color='color',
fill_alpha=0.4,
size=10,
source=source,
legend='predictor')
hover = p.select(dict(type=HoverTool))
hover.tooltips = OrderedDict([
("name", "@name"),
("length", "@length"),
("binders", "@binders"),
("binder_density", "@binder_density"),
("top_peptide", "@top_peptide"),
("max_score", "@max_score"),
])
p.toolbar.logo = None
if savepath != None:
url = "http://*****:*****@name" % savepath
taptool = p.select(type=TapTool)
taptool.callback = OpenURL(url=url)
callback = CustomJS(args=dict(source=source),
code="""
var data = source.data;
var f = cb_obj.value
data['x'] = f
source.trigger('change');
source.change.emit();
""")
from bokeh.layouts import widgetbox
from bokeh.models.widgets import Select
menu = [(i, i) for i in df.columns]
select = Select(title='X', value='A', options=list(df.columns), width=8)
select.js_on_change('value', callback)
#layout = column(p, select, sizing_mode='scale_width')
return p
def modify_doc(doc):
def change_categorical():
'''
bokeh plot application for categorical variables
'''
def update_bars(attr, old, new):
'''
callback for reindexing x-axis with slider
'''
data = df[select.value].value_counts()
if radio_button_group.active == 1:
data = data.sort_index()
start = int(round(new[0], 0))
end = int(round(new[1], 0)) + 1
data = data.iloc[start:end]
keys = data.keys().tolist()
vals = data.values
p.x_range.factors = keys
datasource.data = {'x': keys, 'top': vals}
def update_barsort(attr, old, new):
'''
callback for changing sort method of bars
'''
data = df[select.value].value_counts()
range_slider.value = (range_slider.start, range_slider.end)
if new == 1:
data = data.sort_index()
keys = data.keys().tolist()
vals = data.values
p.x_range.factors = keys
datasource.data = {'x': keys, 'top': vals}
# ============================
# Plot Setup (Categorical)
# ============================
# fetch data
data = df[select.value].value_counts()
categories = len(data) - 1
keys = data.keys().tolist()
vals = data.values
datasource = ColumnDataSource({'x': keys, 'top': vals})
# create plot
p = figure(x_range=keys,
plot_height=600,
plot_width=680,
min_border_bottom=200,
min_border_left=80)
p.vbar(x='x', top='top', width=0.9, source=datasource)
# format plot
p.xaxis.major_label_orientation = math.pi / 2
p.yaxis.axis_label = 'count'
p.title.text = 'Barchart of {}'.format(select.value)
p.xgrid.visible = False
# create interactive tools
range_slider = RangeSlider(start=0,
end=categories,
value=(0, categories),
step=1,
title="Index Selector")
radio_button_group = RadioButtonGroup(
labels=["Sort by y-axis", "Sort by x-axis"], active=0)
range_slider.on_change('value', update_bars)
radio_button_group.on_change('active', update_barsort)
# add to application
root = column(
row(
column(widgetbox(radio_button_group),
widgetbox(range_slider)), Spacer(height=150)), p)
doc.add_root(root)
if len(doc.roots) == 3:
# remove plots for previous column variable
doc.remove_root(doc.roots[1])
def change_numeric():
'''
bokeh plot application for numeric variables
'''
def make_title(label, minval, maxval):
'''
adds title to plot with minimum and maximum limits if specified
'''
title = 'Histogram'
if label is not None:
title += ' of {}'.format(label)
if minval != '':
title += '; Minimum={}'.format(minval)
if maxval != '':
title += '; Maximum={}'.format(maxval)
return title
def update_data(low, high):
'''
recalculates histograms
'''
hist, edges = np.histogram(data[(data >= low)
& (data <= high)],
bins=bins.value)
datasource.data = {
'top': hist,
'left': edges[:-1],
'right': edges[1:]
}
p.title.text = make_title(label, minval.value, maxval.value)
if low > -1 * np.inf:
p.x_range.start = low
if high < np.inf:
p.x_range.end = high
def update_bins(attr, old, new):
'''
callback for changing number of bins
'''
if minval.value == '':
low = -1 * np.inf
else:
low = float(minval.value)
if maxval.value == '':
high = np.inf
else:
high = float(maxval.value)
update_data(low, high)
def update_min(attr, old, new):
'''
callback for setting minimum value limit
'''
if new == '':
low = -1 * np.inf
else:
low = float(new)
if maxval.value == '':
high = np.inf
else:
high = float(maxval.value)
update_data(low, high)
def update_max(attr, old, new):
'''
callback for setting maximum value limit
'''
if minval.value == '':
low = -1 * np.inf
else:
low = float(minval.value)
if new == '':
high = np.inf
else:
high = float(new)
update_data(low, high)
# ============================
# Plot Setup (Numeric)
# ============================
# fetch data
label = select.value
data = df[label]
data = data[~data.isna()]
datasource = ColumnDataSource({'top': [], 'left': [], 'right': []})
# create plot
p = figure(plot_height=600,
plot_width=680,
min_border_bottom=200,
min_border_left=80)
p.quad(top='top',
bottom=0,
left='left',
right='right',
alpha=0.4,
source=datasource)
# format plot
p.xaxis.major_label_orientation = math.pi / 2
p.yaxis.axis_label = 'count'
p.below[0].formatter.use_scientific = False
# create interactive tools
bins = Slider(start=10,
end=100,
value=default_bins,
step=1,
title="Bins")
minval = TextInput(value=default_min, title="Min Value:")
maxval = TextInput(value=default_max, title="Max Value:")
bins.on_change('value', update_bins)
minval.on_change('value', update_min)
maxval.on_change('value', update_max)
update_bins(None, None, default_bins)
# add to application
root = column(
row(column(bins, row(minval, maxval)), Spacer(height=150)), p)
doc.add_root(root)
if len(doc.roots) == 3:
# remove plots for previous column variable
doc.remove_root(doc.roots[1])
def update_column(attr, old, new):
'''
callback for changing data to column specified in dropdown
'''
if df[new].dtype in [int, float]:
change_numeric()
else:
change_categorical()
# crette interactive dropdown for column selection
select = Select(title="Column:", value=default_col, options=cols)
select.on_change('value', update_column)
doc.add_root(widgetbox(select))
doc.title = "Histoviewer"
update_column(None, None, select.value)
f.flush()
my_supply = None
supplies_from_file = open('settings.csv', 'r+')
read = csv.reader(supplies_from_file)
supplies_load = []
for val in read:
for subval in val:
supplies_load.append(subval)
apply_button = Button(label='Apply settings')
current_control = TextInput(title='Current control (A)')
ip_control_textbox = TextInput(title='Enter your device\'s IP address')
connect_button = Button(label='Connect to device')
voltage_control = TextInput(title='Voltage control (V)')
power_control = TextInput(title='Power control (W)')
channel_dropdown = Select(title='Channel control', options=['1', '2', '3'])
supply_textbox = TextInput(title='Current supply')
supply_dropdown = MultiSelect(options=supplies_load)
ocp_control = TextInput(title='OCP control (A)')
file_control = TextInput(title='Desired name of save file',
value='readings.csv')
directory_control = TextInput(
title="Absolute path to desired directory (Ex: /home/pi/Documents)")
comment_box = TextInput(title='Annotation (Will add when box is unselected)')
start_button = Button(label='Start recording data')
PS1C1Voltage = figure(x_range=(0, 300),
y_range=(0, 30),
x_axis_label='Time (150 ms)',
y_axis_label='Volts',
title='Power Supply 1 Channel 1 Voltage over time',
plot_width=300,
def modify_doc(doc):
Q_API_key = '2QQxWV_Ycg2ULirbUMxB' # Quandl
AV_API_key = '567TRV8RTL728INO' # Alpha Vantage
# Download WIKI metadata from Quandl via API
url_0 = 'https://www.quandl.com/api/v3/databases/WIKI/metadata?api_key=' + Q_API_key
response_0 = requests.get(url_0)
# Unzip the bytes and extract the csv file into memory
myzip = ZipFile(BytesIO(response_0.content)).extract('WIKI_metadata.csv')
# Read the csv into pandas dataframe
df_0 = pd.read_csv(myzip)
# Clean up the name fields
df_0['name'] = df_0['name'].apply(lambda s: s[:s.find(')') + 1].rstrip())
# Drop extraneous fields and reorder
df_0 = df_0.reindex(columns=['name', 'code'])
# Make widgets
stock_picker = Select(title="Select a Stock",
value=df_0['name'][0],
options=df_0['name'].tolist())
year_picker = Select(title="Select a Year",
value="2018",
options=[str(i) for i in range(2008, 2019)],
width=100)
months = [
"January", "February", "March", "April", "May", "June", "July",
"August", "September", "October", "November", "December"
]
month_picker = Select(title="Select a Month",
value="January",
options=months,
width=150)
widgets = row(stock_picker, year_picker, month_picker)
# Get data
def get_data(AV_API_key, ticker):
from alpha_vantage.timeseries import TimeSeries
ts = TimeSeries(key=AV_API_key)
data, metadata = ts.get_daily(ticker, 'full')
data_dict = {}
for sub in data.values():
for key, value in sub.items():
data_dict.setdefault(key[3:], []).append(float(value))
data_dict['date'] = list(data.keys())
df = pd.DataFrame.from_dict(data_dict)
df['date'] = pd.to_datetime(df['date'])
df = df.iloc[::-1].reset_index(drop=True)
# do some finance things
df['inc'] = df.close > df.open
df['inc'] = df['inc'].apply(lambda bool: str(bool))
def SMA(n, s):
return [s[0]] * n + [np.mean(s[i - n:i]) for i in range(n, len(s))]
def EMA(n, s):
k = 2 / (n + 1)
ema = np.zeros(len(s))
ema[0] = s[0]
for i in range(1, len(s) - 1):
ema[i] = k * s[i] + (1 - k) * ema[i - 1]
return ema
df['ema12'] = EMA(12, df['open'])
df['ema26'] = EMA(26, df['open'])
df['macd'] = df['ema12'] - df['ema26']
df['signal'] = EMA(9, df['macd'])
df['zero'] = df['volume'].apply(lambda x: x * 0)
df['hist'] = df.macd - df.signal
df['histc'] = df.macd > df.signal
df['histc'] = df['histc'].apply(lambda bool: str(bool))
return df
# Make figure
df = get_data(AV_API_key, 'A')
data_dict = df.to_dict('series')
source = ColumnDataSource(data=data_dict)
# create a new plot with a datetime axis type
p1 = figure(plot_height=400,
x_axis_type="datetime",
tools="xwheel_pan,xwheel_zoom,pan,box_zoom",
active_scroll='xwheel_zoom')
p2 = figure(plot_height=150,
x_axis_type="datetime",
x_range=p1.x_range,
tools="xwheel_pan,xwheel_zoom,pan,box_zoom",
active_scroll='xwheel_pan')
p3 = figure(plot_height=250,
x_axis_type="datetime",
x_range=p1.x_range,
tools="xwheel_pan,xwheel_zoom,pan,box_zoom",
active_scroll='xwheel_pan')
# create price glyphs and volume glyph
p1O = p1.line(x='date',
y='open',
source=source,
color=Spectral5[0],
alpha=0.8,
legend="OPEN")
p1C = p1.line(x='date',
y='close',
source=source,
color=Spectral5[1],
alpha=0.8,
legend="CLOSE")
p1L = p1.line(x='date',
y='low',
source=source,
color=Spectral5[4],
alpha=0.8,
legend="LOW")
p1H = p1.line(x='date',
y='high',
source=source,
color=Spectral5[3],
alpha=0.8,
legend="HIGH")
p1.line(x='date',
y='ema12',
source=source,
color="magenta",
legend="EMA-12")
p1.line(x='date', y='ema26', source=source, color="black", legend="EMA-26")
color_mapper = CategoricalColorMapper(factors=["True", "False"],
palette=["green", "red"])
p1.segment(x0='date',
y0='high',
x1='date',
y1='low',
color={
'field': 'inc',
'transform': color_mapper
},
source=source)
width_ms = 12 * 60 * 60 * 1000 # half day in ms
p1.vbar(x='date',
width=width_ms,
top='open',
bottom='close',
color={
'field': 'inc',
'transform': color_mapper
},
source=source)
p2V = p2.varea(x='date',
y1='volume',
y2='zero',
source=source,
color="black",
alpha=0.8)
p3.line(x='date', y='macd', source=source, color="green", legend="MACD")
p3.line(x='date', y='signal', source=source, color="red", legend="Signal")
p3.vbar(x='date',
top='hist',
source=source,
width=width_ms,
color={
'field': 'histc',
'transform': color_mapper
},
alpha=0.5)
# Add HoverTools to each line
p1.add_tools(
HoverTool(tooltips=[('Date', '@date{%F}'), ('Open', '@open{($ 0.00)}'),
('Close', '@close{($ 0.00)}'),
('Low', '@low{($ 0.00)}'),
('High', '@high{($ 0.00)}'),
('Volume', '@volume{(0.00 a)}')],
formatters={'date': 'datetime'},
mode='mouse'))
p2.add_tools(
HoverTool(tooltips=[('Date', '@date{%F}'), ('Open', '@open{($ 0.00)}'),
('Close', '@close{($ 0.00)}'),
('Low', '@low{($ 0.00)}'),
('High', '@high{($ 0.00)}'),
('Volume', '@volume{(0.00 a)}')],
formatters={'date': 'datetime'},
mode='mouse'))
p3.add_tools(
HoverTool(tooltips=[('Date', '@date{%F}'),
('EMA-12', '@ema12{($ 0.00)}'),
('EMA-26', '@ema26{($ 0.00)}'),
('MACD', '@macd{($ 0.00)}'),
('Signal', '@signal{($ 0.00)}')],
formatters={'date': 'datetime'},
mode='mouse'))
p1.toolbar.logo = None
p2.toolbar.logo = None
p3.toolbar.logo = None
# Add legend
p1.legend.orientation = 'horizontal'
p1.legend.title = 'Daily Stock Price'
p1.legend.click_policy = "hide"
p1.legend.location = "top_left"
p3.legend.orientation = 'horizontal'
p3.legend.location = "top_left"
p3.legend.orientation = 'horizontal'
p3.legend.title = 'Moving Average Convergence Divergence'
p3.legend.location = "top_left"
# Add axis labels
#p1.xaxis.axis_label = 'Date'
#p3.xaxis.axis_label = 'Date'
p2.xaxis.axis_label = 'Date'
p1.yaxis.axis_label = 'Price ($USD/share)'
p2.yaxis.axis_label = 'Volume (shares)'
p3.yaxis.axis_label = 'Indicator ($USD)'
# Add tick formatting
p1.yaxis[0].formatter = NumeralTickFormatter(format="$0.00")
p2.yaxis[0].formatter = NumeralTickFormatter(format="0.0a")
p3.yaxis[0].formatter = NumeralTickFormatter(format="$0.00")
p1.outline_line_width = 1
p2.outline_line_width = 1
p3.outline_line_width = 1
# Activate tools
#p1.toolbar.active_scroll = 'xwheel_zoom'
#p2.toolbar.active_scrool = 'xwheel_pan'
# Set up callbacks
def update_data(attrname, old, new):
# Get the current Select value
ticker = df_0.loc[df_0['name'] == stock_picker.value, 'code'].iloc[0]
print('ticker:', ticker)
# Get the new data
df = get_data(AV_API_key, ticker)
dfi = df.set_index(['date'])
data_dict = df.to_dict('series')
data_dict = {k: data_dict[k][::-1] for k in data_dict.keys()}
source.data = ColumnDataSource(data=data_dict).data
def update_axis(attrname, old, new):
# Get the current Select values
source.data = ColumnDataSource(data=data_dict).data
year = year_picker.value
month = f'{months.index(month_picker.value) + 1:02d}'
start = datetime.strptime(f'{year}-{month}-01', "%Y-%m-%d")
if month == '12':
end = datetime.strptime(f'{str(int(year)+1)}-01-01', "%Y-%m-%d")
else:
end = datetime.strptime(f'{year}-{int(month)+1:02d}-01',
"%Y-%m-%d")
p1.x_range.start = start
p1.x_range.end = end
dfi = df.set_index(['date'])
p1.y_range.start = dfi.loc[end:start]['low'].min() * 0.95
p1.y_range.end = dfi.loc[end:start]['high'].max() * 1.05
p2.y_range.start = dfi.loc[end:start]['volume'].min() * 0.95
p2.y_range.end = dfi.loc[end:start]['volume'].max() * 1.05
p3.y_range.start = dfi.loc[end:start]['macd'].min() * 0.75
p3.y_range.end = dfi.loc[end:start]['macd'].max() * 1.25
# setup JScallback
JS = '''
clearTimeout(window._autoscale_timeout);
var date = source.data.date,
low = source.data.low,
high = source.data.high,
volume = source.data.volume,
macd = source.data.macd,
start = cb_obj.start,
end = cb_obj.end,
min1 = Infinity,
max1 = -Infinity,
min2 = Infinity,
max2 = -Infinity,
min3 = Infinity,
max3 = -Infinity;
for (var i=0; i < date.length; ++i) {
if (start <= date[i] && date[i] <= end) {
max1 = Math.max(high[i], max1);
min1 = Math.min(low[i], min1);
max2 = Math.max(volume[i], max2);
min2 = Math.min(volume[i], min2);
max3 = Math.max(macd[i], max3);
min3 = Math.min(macd[i], min3);
}
}
var pad1 = (max1 - min1) * .05;
var pad2 = (max2 - min2) * .05;
var pad3 = (max3 - min3) * .05;
window._autoscale_timeout = setTimeout(function() {
y1_range.start = min1 - pad1;
y1_range.end = max1 + pad1;
y2_range.start = min2 - pad2;
y2_range.end = max2 + pad2;
y3d = Math.max(Math.abs(min3 - pad3), Math.abs(max3 + pad3))
y3_range.start = -y3d;
y3_range.end = y3d;
});
'''
callbackJS = CustomJS(args={
'y1_range': p1.y_range,
'y2_range': p2.y_range,
'y3_range': p3.y_range,
'source': source
},
code=JS)
p1.x_range.js_on_change('start', callbackJS)
p1.x_range.js_on_change('end', callbackJS)
stock_picker.on_change('value', update_data)
year_picker.on_change('value', update_axis)
month_picker.on_change('value', update_axis)
b = Button(label='Full History')
b.js_on_click(
CustomJS(args=dict(p1=p1, p2=p2),
code="""
p1.reset.emit()
p2.reset.emit()
"""))
c = column(Div(text="", height=8), b, width=100)
# Set up layouts and add to document
row1 = row(stock_picker,
year_picker,
month_picker,
c,
height=65,
width=800,
sizing_mode='stretch_width')
row2 = row(p1, width=800, height=400, sizing_mode='stretch_width')
row3 = row(p2, width=800, height=150, sizing_mode='stretch_width')
row4 = row(p3, width=800, height=250, sizing_mode='stretch_width')
layout = column(row1,
row2,
row4,
row3,
width=800,
height=800,
sizing_mode='scale_both')
doc.add_root(layout)
+ dt_picker.value.strftime('%Y-%m-%d') \
+ " with option " + dummy_select.value
def updateBtn():
update(attrname=None, old=None, new=None)
text_input = TextInput(value="Ivana")
button = Button(label="Generate Text")
dt_picker_ = DatePicker(min_date='2010-01-01',
max_date='2018-03-28',
value='2018-03-27')
dummy_select = Select(value='select an option', options=['a', 'b'])
output = Paragraph()
button.on_click(updateBtn)
dummy_select.on_change('value', update)
dt_picker.on_change('value', update)
lay_out = layout([[text_input, button, dt_picker], [output]])
#show(lay_out)
#curdoc().add_root(lay_out)
# curdoc().add_root(
# column(
# row(text_input),
def getBokehComponent(self):
self.select = Select(title=self._settings['title'],
value=self._settings["value"],
options=self._settings['options'])
return self.select
import numpy as np
import pandas as pd
from bokeh.models import ColumnDataSource, Plot
from bokeh.plotting import figure, curdoc
from bokeh.properties import String, Instance
from bokeh.server.app import bokeh_app
from bokeh.server.utils.plugins import object_page
from bokeh.models.widgets import (HBox, VBox, VBoxForm, PreText, Select,
AppHBox, AppVBox, AppVBoxForm)
from bokeh.simpleapp import simpleapp
select1 = Select(name='ticker1',
value='AAPL',
options=['AAPL', 'GOOG', 'INTC', 'BRCM', 'YHOO'])
select2 = Select(name='ticker2',
value='GOOG',
options=['AAPL', 'GOOG', 'INTC', 'BRCM', 'YHOO'])
@simpleapp(select1, select2)
def stock(ticker1, ticker2):
pretext = PreText(text="", width=500)
df = get_data(ticker1, ticker2)
source = ColumnDataSource(data=df)
source.tags = ['main_source']
p = figure(
title="%s vs %s" % (ticker1, ticker2),
plot_width=400,
from bokeh.models.widgets import Select
from bokeh.io import curdoc
from plot_options import apply_plot_options
world = pd.read_csv(join(dirname(__file__), "data.csv"))
axis_map = {
"GNP Per-Capita (USD)": "per_cap_gnp",
"Life Expectancy (years)": "lifeexpectancy",
"Surface Area (sq km)": "surfacearea",
"Year of Independence": "indepyear"
}
# Create Input controls
ctry_selec = Select(title="Country",
options=sorted(set(world.country.values)),
value='All')
regn_selec = Select(title="Region",
options=sorted(set(world.region.values)),
value='All')
cont_selec = Select(title="Continent",
options=sorted(set(world.continent.values)),
value='All')
govt_selec = Select(title="Form of Government",
options=sorted(set(world.govtform.values)),
value='All')
x_axis = Select(title="X-Axis (choose quantity to plot)",
options=sorted(axis_map.keys()),
value='GNP Per-Capita (USD)')
y_axis = Select(title="Y-Axis (choose quantity to plot)",
options=sorted(axis_map.keys()),
def generate_summary_plot():
#x = [x*0.005 for x in range(0, 200)]
#y = x
x = np.arange(0, 10)
#x = [x*0.005 for x in range(0, 200)]
y = [i*i for i in x]
z = [i*3.0 for i in x]
source = ColumnDataSource(data=dict(x=x, y=y))
source2 = ColumnDataSource(data=dict(x=x, z=z))
print(source)
print(dict(source=source))
summary_fig = figure(x_axis_location='above', plot_width=400, plot_height=400)
line_one = summary_fig.line('x', 'y', source=source, line_width=3, line_alpha=0.6)#, xaxis.axis_label = 'initalized')#,axis.axis_label='title')
line_two = summary_fig.line('x', 'z', source=source2, line_width=3, line_alpha=0.6)#, xaxis.axis_label = 'initalized')#,axis.axis_label='title')
#selector_options=['alpha','beta','gamma']
#selector1=Select(title='X-Axis',value=selector_options[0],options=selector_options, callback = callback)
#summary_fig.xaxis.visible = None
xaxis = LinearAxis(axis_label="Initial x-axis label")
summary_fig.add_layout(xaxis, 'below')
#summary_fig.xaxis.axis_label = 'Time (Years)'
#selector1.on_change('value',callback) #plot.yaxis.axis_label = y_title
#controls = widgetbox([selector1], width=200)
code1 = '''\
object.visible = toggle.active
'''
code2 = '''\
object.visible = radio_button.active
'''
#var f = cb_obj.value
callback2 = CustomJS(args=dict(source=source2), code="""
var data = source.data;
var f = cb_obj.value
x = data['x']
z = data['z']
if (f == "alpha") {
for (i = 0; i < x.length; i++) {
z[i] = Math.pow(x[i], 3.)}
}
else if (f = "beta") {
for (i = 0; i < x.length; i++) {
z[i] = 20}
}
source.trigger('change');
""")
callback3 = CustomJS(args=dict(xaxis=xaxis), code="""
var f = cb_obj.value
xaxis.attributes.axis_label = f
xaxis.trigger('change');
""")
callback4 = CustomJS(args=dict(source=source2), code="""
var data = source.data;
var f = cb_obj.value
x = data['x']
z = data['z']
if (f == "A alpha") {
for (i = 0; i < x.length; i++) {
z[i] = Math.pow(x[i], 3.)}
}
else if (f = "B alpha") {
for (i = 0; i < x.length; i++) {
z[i] = 20}
}
source.trigger('change');
""")
callback1 = CustomJS.from_coffeescript(code=code1, args={})
toggle1 = Toggle(label="Green Box", button_type="success", callback=callback1)
callback1.args = {'toggle': toggle1, 'object': line_one}
#callback2 = CustomJS.from_coffeescript(code=code2, args={})
radio_button_group = RadioButtonGroup(labels=['alpha','beta','gamma'], active=0)# callback=callback2)
radio_button_group.js_on_change('value', callback2)
#print([method for method in dir(radio_button_group)])
#callback2.args = {'radio_button': radio_button_group, 'object': line_two}
#output_file("styling_visible_annotation_with_interaction.html")
selector_options = ['A alpha', 'B beta', 'G gamma']
selector1 = Select(title='X-Axis', value=selector_options[0], options=selector_options)#, callback=callback4)
selector1.js_on_change('value', callback4)
selector2_options = ['Aa alpha', 'Ba beta', 'Ga gamma']
selector2 = Select(title='X-Axis', value=selector_options[0], options=selector2_options)#, callback=callback4)
selector2.js_on_change('value', callback3)
#slider = Slider(start=0.1, end=4, value=1, step=.1, title="power")
#slider.js_on_change('value', callback)
controls = widgetbox([toggle1,radio_button_group, selector1, selector2], width=200)
layout = row(controls, summary_fig)
return layout
"""We're looking to gauge interest in buying some property to satisfy the hippies in the group that want a farm. There are a few important
questions here that need answering to see where everyone's at. Please answer honestly. The answers will be collected and displayed for all, so we can make sound investment decisions.""",
'black',
size=3),
width=1000)
text_input = TextInput(value=" ", title="Name", width=width_number)
text_input.js_on_change(
"value",
CustomJS(
code=
"""console.log('text_input: value=' + this.value, this.toString())"""))
select_property = Select(
title='What type of property are you most interested in?',
value='Land',
options=sorted(['Land', 'Detached', "Townhome", "Condo"]),
width=width_number)
select_property.on_change('value', update_property)
select_time = Select(title='What is your ideal time horizon to own?',
value='1-2 years',
options=[
'1-2 years',
'3-5 years',
'5-10 years',
"10+ years",
],
width=width_number)
select_time.on_change('value', update_time)
############################################################
# Plot using Bokeh
############################################################
# Imports
from bokeh.plotting import figure, ColumnDataSource
from bokeh.models.tools import HoverTool
from bokeh.layouts import widgetbox
from bokeh.models.widgets import Select
from bokeh.io import curdoc
from bokeh.layouts import row, column
# Create drop down menu
select = Select(title="Roller Coaster:", value=rides[3][0], options=[x[0] for x in rides])
# Initialize canvas
p = figure(plot_width=600, plot_height=400)
p.y_range.start = 0
p.y_range.end = 120
lr = []
# Function to draw on canvas for a given roller coaster
def draw_plot(coaster_name):
r = coaster_name
Y = data[r]
day_colors = ['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet']
for i in range(7):
dates = sorted(Y[i].keys())
def line_tab(df):
cluster_indicators = df.columns[2:-1]
clusters = df['Country'].unique()
#define function to create data set for plotting
def create_dataset(data, indicator, selected_clusters):
color_palette = Category20_12
#set color dictionary mapping regions to colors
colormap = {
cluster: color_palette[i]
for i, cluster in enumerate(data['Country'].unique())
}
#subset data by selected clusters
subset = data[data['Country'].isin(selected_clusters)]
#create datasource for plotting points
source_point = ColumnDataSource({
'year':
subset['Year'],
'cluster':
subset['Country'],
'value':
subset[indicator], #values for selected indicator
'colors': [colormap[cluster] for cluster in subset['Country']]
})
#create datasource for plotting lines. for multiple line plotting, data source has to be a list of lists, each list being data points for each group
xs = []
ys = []
colors = []
for cluster in subset['Country'].unique():
df_cluster = subset[subset['Country'] == cluster]
xs.append(list(df_cluster['Year']))
ys.append(list(df_cluster[indicator]))
colors.append(colormap[cluster])
source_line = ColumnDataSource({
'year':
xs,
'value':
ys,
'cluster':
list(subset['Country'].unique()),
'colors':
colors
})
return source_point, source_line
#define function to plot interactive line charts
def create_plot(source_pt, source_line, y):
#create plot figure
p = figure(plot_width=800,
plot_height=500,
title=y,
x_axis_label='Year',
y_axis_label=y,
sizing_mode='scale_both')
#plot lines
p.multi_line('year',
'value',
line_width=1,
color='colors',
source=source_line,
legend='cluster')
#plot points
p.circle('year',
'value',
size=3,
fill_color='white',
line_color='colors',
source=source_pt)
#set plot aesthetics
p.legend.label_text_font_size = '8pt'
p.x_range = Range1d(2001, 2030)
p.xaxis.minor_tick_line_color = None
p.xgrid.grid_line_color = None
p.title.text_font_size = '12pt'
p.xaxis.axis_label_text_font_style = 'normal'
p.yaxis.axis_label_text_font_style = 'normal'
#add hovertool to show details for each data point
hover = HoverTool(tooltips=[
("Cluster: ", "@cluster"),
("Value:", "$y{1.1}"),
])
p.add_tools(hover)
return p
#update plot on user input
def update(attr, old, new):
#get current values of inputs
y = y_select.value
selected_clusters = [
cluster_selection.labels[i] for i in cluster_selection.active
]
#update sources
new_source_pt, new_source_line = create_dataset(
df, y, selected_clusters)
source_pt.data = new_source_pt.data
source_line.data = new_source_line.data
#update labels and titles
p.title.text = y
p.yaxis.axis_label = y
#add selection widget
y_select = Select(title="Select indicator",
value=cluster_indicators[3],
options=list(cluster_indicators))
y_select.on_change('value', update)
#add explanatory text for checkbox group
text = Div(text="""Select cluster""")
#add selection widget
cluster_selection = CheckboxGroup(labels=list(clusters), active=[11])
cluster_selection.on_change('active', update)
#set initial values to current widget values
y = y_select.value
selected_clusters = [
cluster_selection.labels[i] for i in cluster_selection.active
]
#get initial dataset and plot
source_pt, source_line = create_dataset(df, y, selected_clusters)
p = create_plot(source_pt, source_line, y)
#layout widgets and plot
controls = WidgetBox(y_select,
text,
cluster_selection,
width=400,
sizing_mode='scale_both')
layout = row(controls, p)
tab = Panel(child=layout, title='Trend in gender indicators')
return tab
<p><a href="http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html" target="_blank">Click here </a>for more information on the parameters </p>
""",
width=1100)
df = pd.read_csv(datasetname)
y = df[df.columns[:1]].values.ravel()
df1 = df.drop(df.columns[:1], axis=1)
target = Paragraph(text='', name='target')
target.text = "Target feature is " + str(df.columns[:1].tolist())
features = MultiSelect(title="Features", options=df.columns[1:].tolist())
kfold = Slider(start=2, end=10, value=5, step=1, title="No of folds")
fit_intercept = Select(title="Fit_intercept:",
value="True",
options=["True", "False"])
normalize = Select(title="Normalize:",
value="False",
options=["True", "False"])
copy_X = Select(title="Copy_X:", value="True", options=["True", "False"])
stats = Paragraph(text='', width=1000, height=50, name='Selected Features:')
stats2 = Div(text='<h3>Results:</h3>', )
#columns =['avg_dist', 'avg_rating_by_driver','avg_rating_of_driver','avg_surge','surge_pct','trips_in_first_30_days','luxury_car_user','weekday_pct','city_Astapor',"city_KingsLanding",'city_Winterfell','phone_Android','phone_no_phone']
#columns = ['luxury_car_user','avg_dist','city_Astapor',"city_KingsLanding",'phone_Android','phone_iPhone']
#df1 = pd.DataFrame(df, columns=columns)
#y = df['churn']
y = df[df.columns[:1]].values.ravel()
def _plot(self,
result_object,
learning_curves,
hyperparameter_names,
reset_times=False):
# Extract information from learning-curve-dict
times, losses, config_ids, = [], [], []
for conf_id, learning_curves in learning_curves.items():
# self.logger.debug("Config ID: %s, learning_curves: %s", str(conf_id), str(learning_curves))
for l in learning_curves:
if len(l) == 0:
continue
tmp = list(zip(*l))
times.append(tmp[0])
losses.append(tmp[1])
config_ids.append(conf_id)
if reset_times:
times = [np.array(ts) - ts[0] for ts in times]
# Prepare ColumnDataSource
data = OrderedDict([
('config_id', []),
('config_info', []),
('times', []),
('losses', []),
('duration', []),
('HB_iteration', []),
('colors', []),
('colors_performance', []),
('colors_iteration', []),
])
for hp in hyperparameter_names:
data[hp] = []
# Populate
id2conf = result_object.get_id2config_mapping()
for counter, c_id in enumerate(config_ids):
if not (len(times[counter]) == len(losses[counter])):
raise ValueError()
longest_run = self.get_longest_run(c_id, result_object)
if not longest_run:
continue
data['config_id'].append(str(c_id))
try:
config_info = '\n'.join([
str(k) + "=" + str(v)
for k, v in sorted(id2conf[c_id]['config_info'].items())
])
except:
config_info = 'Not Available'
data['config_info'].append(config_info)
data['times'].append(times[counter])
data['losses'].append(losses[counter])
if longest_run:
data['duration'].append(
longest_run['time_stamps']['finished'] -
longest_run['time_stamps']['started'])
else:
data['duration'].append('N/A')
data['HB_iteration'].append(str(c_id[0]))
for hp in hyperparameter_names:
try:
data[hp].append(id2conf[c_id]['config'][hp])
except KeyError:
data[hp].append("None")
data['colors'].append(losses[counter][-1])
data['colors_performance'].append(losses[counter][-1])
data['colors_iteration'].append(c_id[0])
# Tooltips
tooltips = [(key, '@' + key) for key in data.keys() if not key in [
'times', 'duration', 'colors', 'colors_performance',
'colors_iteration'
]]
tooltips.insert(4, ('duration (sec)', '@duration'))
tooltips.insert(5, ('Configuration', ' '))
hover = HoverTool(tooltips=tooltips)
# Create sources
source_multiline = ColumnDataSource(data=data)
# Special source for scattering points, since times and losses for multi_line are nested lists
scatter_data = {key: [] for key in data.keys()}
for idx, c_id in enumerate(data['config_id']):
for t, l in zip(data['times'][idx], data['losses'][idx]):
scatter_data['times'].append(t)
scatter_data['losses'].append(l)
for key in list(data.keys()):
if key in ['times', 'losses']:
continue
scatter_data[key].append(data[key][idx])
source_scatter = ColumnDataSource(data=scatter_data)
# Color
min_perf, max_perf = min([l[-1] for l in data['losses']
]), max([l[-1] for l in data['losses']])
min_iter, max_iter = min([int(i) for i in data['HB_iteration']]), max(
[int(i) for i in data['HB_iteration']])
color_mapper = LinearColorMapper(palette=Spectral11,
low=min_perf,
high=max_perf)
# Create plot
y_axis_type = "log" if len(
[a for a in scatter_data['losses'] if a <= 0]) == 0 else 'linear'
x_min, x_max = min(scatter_data['times']), max(scatter_data['times'])
x_pad = (x_max - x_min) / 10
x_min -= x_pad
x_max += x_pad
y_min, y_max = min(scatter_data['losses']), max(scatter_data['losses'])
y_pad = (y_max - y_min) / 10
y_min -= (
y_min / 10
) if y_axis_type == 'log' else y_pad # because this must not fall below 0 if it's a logscale
y_max += y_pad * 10 if y_axis_type == 'log' else y_pad
p = figure(
plot_height=500,
plot_width=600,
y_axis_type=y_axis_type,
tools=[hover, 'save', 'pan', 'wheel_zoom', 'box_zoom', 'reset'],
x_axis_label='Time',
y_axis_label='Cost',
x_range=Range1d(x_min, x_max, bounds='auto'),
y_range=Range1d(y_min, y_max, bounds='auto'),
)
# Plot per HB_iteration, each config individually
HB_iterations = sorted(set(data['HB_iteration']))
max_label_len = max([len(l) for l in HB_iterations])
HB_handles, HB_labels = [], []
self.logger.debug(
"Assuming config_info to be either \"model_based_pick=True\" or \"model_based_pick=False\""
)
for it in HB_iterations:
line_handles = []
view = CDSView(source=source_multiline,
filters=[
GroupFilter(column_name='HB_iteration',
group=str(it))
])
line_handles.append(
p.multi_line(
xs='times',
ys='losses',
source=source_multiline,
view=view,
color={
'field': 'colors',
'transform': color_mapper
},
alpha=0.5,
line_width=5,
))
# Separate modelbased and random
view = CDSView(source=source_scatter,
filters=[
GroupFilter(column_name='HB_iteration',
group=str(it)),
GroupFilter(column_name='config_info',
group="model_based_pick=True")
])
line_handles.append(
p.circle_x(
x='times',
y='losses',
source=source_scatter,
view=view,
fill_color={
'field': 'colors',
'transform': color_mapper
},
fill_alpha=0.5,
line_color='colors',
size=20,
))
view = CDSView(source=source_scatter,
filters=[
GroupFilter(column_name='HB_iteration',
group=str(it)),
GroupFilter(column_name='config_info',
group="model_based_pick=False")
])
line_handles.append(
p.circle(
x='times',
y='losses',
source=source_scatter,
view=view,
fill_color={
'field': 'colors',
'transform': color_mapper
},
fill_alpha=0.5,
line_color='colors',
size=20,
))
HB_handles.append(line_handles)
HB_labels.append('warmstart data' if l in
[-1, '-1'] else '{number:0{width}d}'.
format(width=max_label_len, number=int(it)))
# Sort all lists according to label
HB_iterations, HB_handles, HB_labels = zip(*sorted(
zip(HB_iterations, HB_handles, HB_labels), key=lambda tup: tup[2]))
HB_iterations, HB_handles, HB_labels = list(HB_iterations), list(
HB_handles), list(HB_labels)
self.logger.debug("HB_iterations to labels: %s",
str(list(zip(HB_iterations, HB_labels))))
checkbox, select_all, select_none = get_checkbox(HB_handles, HB_labels)
callback_color = CustomJS(args=dict(source_multiline=source_multiline,
source_scatter=source_scatter,
cm=color_mapper),
code="""
var data_multiline = source_multiline.data;
var data_scatter = source_scatter.data;
var min_perf = {0};
var max_perf = {1};
var min_iter = {2};
var max_iter = {3};
if (cb_obj.value == 'performance') {{
data_multiline['colors'] = data_multiline['colors_performance'];
data_scatter['colors'] = data_scatter['colors_performance'];
cm.low = min_perf;
cm.high = max_perf;
}} else {{
data_multiline['colors'] = data_multiline['colors_iteration'];
data_scatter['colors'] = data_scatter['colors_iteration'];
cm.low = min_iter;
cm.high = max_iter;
}}
source.change.emit();
""".format(min_perf, max_perf, min_iter, max_iter))
select_color = Select(title="Select colors",
value="performance",
options=["performance", "iteration"],
callback=callback_color)
# Put it all together in a layout (width of checkbox-field sizes with number of elements
width_of_checkbox = 650 if len(HB_labels) > 100 else 500 if len(
HB_labels) > 70 else 400
layout = row(
p,
column(
widgetbox(checkbox, width=width_of_checkbox),
row(widgetbox(select_all, width=50),
widgetbox(select_none, width=50)),
widgetbox(select_color, width=200)))
return layout
############## sources ##############
source3 = ColumnDataSource(data=get_most_similar_auto_complete(df, dfe, string_input, TOP_N))
############## plot ##############
title_no = [str(x) for x in range(TOP_N+1, 0, -1)] #['4', '3', '2', '1']
p = Figure(y_range=title_no, tools="", toolbar_location=None, x_range=[0, 3], x_axis_label='Expected View Count', plot_width=500, plot_height=300)
p.hbar(y = 'title_no', right = 'pred', fill_alpha=0.8, height= 0.1, source=source3)
############## inputs ##############
string_input2 = TextInput(value='Data Scientist', title="Enter Your Job Ad Title here")
select_city = Select(options=list(df['city'].unique()), value='Zürich', title='choose a city')
select_package = Select(options=['A', 'B', 'C', 'D'], value='D', title='choose a package')
select_contract_pct_from = Select(options=[str(x) for x in range(10, 110, 10)], value='100', title='choose from %')
select_contract_pct_to = Select(options=[str(x) for x in range(10, 110, 10)], value='100', title='choose to %')
select_industry = Select(options=list(df['industry_name'].unique()), value='Industrie diverse', title='choose an industry')
############## updates ##############
def update_pred(attrname, old, new):
string_input = string_input2.value
package_id = select_package.value
contract_pct_from = select_contract_pct_from.value
