def _create_fill_map(
source: ColumnDataSource,
source_column: str = None
) -> Tuple[Union[factor_cmap, linear_cmap], Optional[ColorBar]]:
"""Create factor map or linear map based on `source_column`."""
fill_map = "navy"
color_bar = None
if source_column is None or source_column not in source.data:
return fill_map, color_bar
col_kind = source.data[source_column].dtype.kind
if col_kind in ["b", "O"]:
s_values = set(source.data[source_column])
if np.nan in s_values:
s_values.remove(np.nan)
values = list(s_values)
fill_map = factor_cmap(source_column,
palette=viridis(max(3, len(values))),
factors=values)
elif col_kind in ["i", "u", "f", "M"]:
values = [
val for val in source.data[source_column] if not np.isnan(val)
]
fill_map = linear_cmap(
field_name=source_column,
palette=viridis(256),
low=np.min(values),
high=np.max(values),
)
color_bar = ColorBar(
color_mapper=fill_map["transform"],
width=8,
location=(0, 0) # type: ignore
)
return fill_map, color_bar
def plot_output(out,attribute,attribute_label,labels,lines,**kwargs):
condensibles = out[0]['condensibles']
kwargs['plot_height'] = kwargs.get('plot_height',300)
kwargs['plot_width'] = kwargs.get('plot_width',600)
kwargs['x_axis_label'] = kwargs.get('x_axis_label',attribute_label)
kwargs['y_axis_label'] = kwargs.get('y_axis_label','Pressure (bars)')
kwargs['x_axis_type'] = kwargs.get('x_axis_type','log')
kwargs['y_axis_type'] = kwargs.get('y_axis_type','log')
cols = viridis(len(out))
pressure = out[0]['pressure']
kwargs['y_range'] = kwargs.get('y_range',[np.max(pressure), np.min(pressure)])
fig = figure(**kwargs)
for i in range(len(out)):
x = out[i][attribute][:,0]
if attribute is "column_density":
x = out[i][attribute][:,0]/out[i]["layer_thickness"]
pressure = out[i]['pressure']
fig.line(x, pressure, legend_label=labels[i], color=cols[i],line_width=5, line_dash=lines[i])
fig.legend.location = "bottom_left"
plot_format(fig)
return fig
def plot_true_graph(sample_data, num_tracks=100):
p = figure(title='Truth graph',
x_axis_label='x',
y_axis_label='y',
height=800,
width=800)
true_edges = sample_data.signal_true_edges
true_unique, true_lengths = sample_data.pid[true_edges[0]].unique(
return_counts=True)
pid = sample_data.pid
r, phi, z = sample_data.cpu().x.T
x, y = r * np.cos(phi * np.pi), r * np.sin(phi * np.pi)
cmap = viridis(num_tracks)
source = ColumnDataSource(dict(x=x.numpy(), y=y.numpy()))
p.circle(x='x', y='y', source=source, color=cmap[0], size=1, alpha=0.1)
for i, track in enumerate(true_unique[true_lengths >= 5][:num_tracks]):
# Get true track plot
track_true_edges = true_edges[:, pid[true_edges[0]] == track]
X_edges, Y_edges = x[track_true_edges].numpy(
), y[track_true_edges].numpy()
X = np.concatenate(X_edges)
Y = np.concatenate(Y_edges)
p.circle(X, Y, color=cmap[i], size=5)
p.multi_line(X_edges.T.tolist(), Y_edges.T.tolist(), color=cmap[i])
show(p)
def pieChart(df):
bokeh.io.output_file('static/graphics/pie.html')
labels = list(df['source'].unique())
cant = list(df['source'].value_counts())
x = {labels[i]: cant[i] for i in range(len(labels))}
data = pd.Series(x).reset_index(name='value').rename(
columns={'index': 'country'})
data['angle'] = data['value'] / data['value'].sum() * 2 * pi
data['color'] = viridis(len(x))
p = figure(plot_height=350,
title="Pie Chart",
toolbar_location=None,
tools="hover",
tooltips="@country: @value",
x_range=(-0.5, 1.0))
p.wedge(x=0,
y=1,
radius=0.4,
start_angle=cumsum('angle', include_zero=True),
end_angle=cumsum('angle'),
line_color="white",
fill_color='color',
legend_field='country',
source=data)
p.axis.axis_label = None
p.axis.visible = False
p.grid.grid_line_color = None
# output_file('static/graphics/pie.html')
return p
def prep_palette(self, pname, binverse=False):
"""
Prepares a palette based on a name
:param pname:
:return:
"""
res = palettes.grey(256)
if pname == 'Greys256':
res = palettes.grey(256)
elif pname == 'Inferno256':
res = palettes.inferno(256)
elif pname == 'Magma256':
res = palettes.magma(256)
elif pname == 'Plasma256':
res = palettes.plasma(256)
elif pname == 'Viridis256':
res = palettes.viridis(256)
elif pname == 'Cividis256':
res = palettes.cividis(256)
elif pname == 'Turbo256':
res = palettes.turbo(256)
elif pname == 'Bokeh8':
res = palettes.small_palettes['Bokeh'][8]
elif pname == 'Spectral11':
res = palettes.small_palettes['Spectral'][11]
elif pname == 'RdGy11':
res = palettes.small_palettes['RdGy'][11]
elif pname == 'PiYG11':
res = palettes.small_palettes['PiYG'][11]
if binverse:
res = res[::-1]
return res
def plot(self):
figure = Figure(**self._plot_args)
palette = viridis(len(self.model.data.columns))
color_index = {
c: palette[i]
for i, c in enumerate(self.model.data.columns)
}
# instantiating view on render
view = self.bokeh_view(ignore_filters=True)
# by default : lines
for c in self.model.data.columns:
# CAREFUL : CDSView used by Glyph renderer must have a source that matches the Glyph renderer's data source
figure.line(
source=view.source,
view=view,
x="index",
y=c,
color=color_index[c],
legend_label=c,
)
return figure
def houseStockPlot():
df = pd.read_csv('BokehApp/Data/houseStock1.csv')
df = df[['Year', 'Dublin_Vacant', 'Irl_Vacant', 'Dublin_Total','Irl_Total']]
df.columns = ['Year', 'Dublin vacant', 'Ireland vacant', 'Dublin', 'Ireland']
ll = list(df.columns[1:])
source = ColumnDataSource(data=dict(x=df.Year.values,y=df['Ireland'], y1=df['Dublin'], y2=df['Ireland vacant'], y3=df['Dublin vacant']))
a2 = figure(plot_width=550, plot_height=350, title='Irish House Stock', tools = 'pan, wheel_zoom, box_zoom, reset') #, tooltips=ToolTips)
hover = HoverTool()
hover.tooltips=[('Ireland', '@y'), ('Dublin','@y1'), ('Ireland vancant', '@y2'), ('Dublin vacant','@y3')]
a2.add_tools(hover)
colors = viridis(4)
a2.varea_stack(['y3','y2','y1','y'], x='x', source=source, color=colors[::-1], legend=ll, muted_alpha=0.2)
a2.legend.location='top_left'
a2.legend.click_policy="mute"
a2.yaxis[0].formatter = NumeralTickFormatter(format="0 M")
tick_labels = {'500000':'0.5M','1000000':'1M','1500000':'1,5M','2000000':'2M','2500000':'2,5M'}
a2.yaxis.major_label_overrides = tick_labels
a2.xaxis.ticker = df.Year.values
a2.title.text_font_size = '15px'
a2.legend.background_fill_alpha=None
a2.legend.border_line_alpha=0
a2.legend.label_text_font_size = "11px"
a2.xaxis.major_label_text_font_style = 'bold'
a2.grid.grid_line_color=None
a2.toolbar.autohide = True
a2.outline_line_color=None
return a2
def __init__(
self,
fig: Figure,
x_bounds: tuple,
y_bounds: tuple,
grid_size: float,
legend_label: str,
):
"""
Creates a HeatmapPlotter for the given figure, with the given x-axis and y-axis bounds and
grid cell size. This will show up in the Bokeh figure legend as legend_label.
:param fig: a Bokeh figure
:param x_bounds: the x-axis bounds of the heatmap
:param y_bounds: the y-axis bounds of the heatmap
:param grid_size: the size of a grid cell on the heatmap
:param legend_label: the legend label of the heatmap
"""
self.image_data_source = ColumnDataSource(dict(image=[]))
self.x_bounds = x_bounds
self.y_bounds = y_bounds
self.grid_size = grid_size
fig.image(
source=self.image_data_source,
image="image",
x=min(x_bounds),
y=min(y_bounds),
dh=max(y_bounds) - min(y_bounds),
dw=max(x_bounds) - min(x_bounds),
palette=palettes.viridis(100),
level="image",
legend_label=legend_label,
)
def piechart(src, heads, val, acci, title=''):
title = title + accisev[acci] + " casualties, " + val + " by " + heads
src.columns = src.columns.get_level_values(0)
src['angle'] = src[val] / src[val].sum() * 2 * pi
src['percent'] = src[val] / src[val].sum() * 100.00
src['color'] = viridis(len(src.index))
p = figure(plot_height=350,
title=title,
toolbar_location=None,
tools="hover",
tooltips="@" + heads + ": @" + val + ", @percent",
x_range=(-0.5, 1.0))
p.wedge(x=0,
y=1,
radius=0.4,
start_angle=cumsum('angle', include_zero=True),
end_angle=cumsum('angle'),
line_color="white",
fill_color='color',
legend=heads,
source=src)
p.axis.axis_label = None
p.axis.visible = False
p.grid.grid_line_color = None
show(p)
def plotDateGrid(date):
# Assert given date is available.
assert date in authorKey(df, 'Capella',
'date'), 'No entries for this date.'
# Create list of fitting dataframes
tempList = [
biblioList[s] for s in range(len(biblioList))
if biblioList[s]['date'][0] in [date]
]
# sort by occuring diagrams
dfDATE = sorted(tempList,
key=lambda tempList: tempList['Count'].sum(),
reverse=True)
plotListDATE = []
for x in range(len(dfDATE)):
titleS = dfDATE[x]['biblio'][0] + '; ' + str(
dfDATE[x]['date'][0]) + ' CE'
b0 = Bar(dfDATE[x],
title=titleS,
label='biblio',
values='Count',
group='diaTyp',
bar_width=1,
ylabel='Diagrams',
palette=viridis(14),
width=250,
height=250,
legend=False)
b0.xaxis.major_label_orientation = "horizontal"
b0.xaxis.axis_label = ''
plotListDATE.append(b0)
plotGrid = gridplot(plotListDATE, ncols=3)
show(plotGrid)
def ticker1_change(attrname, old, new):
""" Loads WT-MT data again and starts ... """
print(old, new)
tsneResDF2, data4umap2 = load_data()
# randomely select 3 sites
uniqLabels0 = tsneResDF2['Label'].unique().tolist()
randIntArr = np.random.randint(1, len(uniqLabels0), size=3)
randSites = [uniqLabels0[i] for i in randIntArr]
tsneResDF2m = tsneResDF2[tsneResDF2['Label'].isin(randSites)].reset_index(
drop=True)
source2.data = ColumnDataSource(data4umap2).data #### update source2
# print('shapeHere',tsneResDF2.shape,data4umap2.shape)
d2 = gen_data_forHover(tsneResDF2m)
uniqLabels = tsneResDF2m['Label'].unique().tolist()
# palette1 = inferno(len(uniqLabels))
# colors = [palette1[int(uniqLabels.index(x))] for x in tsneResDF2m['Label']]
palette1 = all_palettes['Colorblind'][len(uniqLabels)]
colors = [palette1[int(uniqLabels.index(x))] for x in tsneResDF2m['Label']]
# colors = [colormap[x] for x in tsneResDF2['Label']]
d2["color"] = colors
source.data = d2 #### update source
dCls2 = gen_data_forHover(tsneResDF2)
palette2 = viridis(len(tsneResDF2['clsLabel'].unique()))
colors2 = [palette2[int(x)] for x in tsneResDF2['clsLabel']]
dCls2['color'] = colors2
source3.data = dCls2 #### update source3
mem_stream.send(tsneResDF2) #### update boxplot
series.children = [ticker1] + [row(p, p2, column(stats2, p1))] + []
def plot_per(fold_list):
df = pd.read_csv('/home/dhrumil/Desktop/Lab/RNAWebsite_v1/GeneratePlot/data/foldability_prediction.csv', header=0)
f_list = df[df['foldability'] > 0]['foldability'].tolist()
print(len(f_list))
plot = figure(title="Foldability", tools="box_zoom, pan, save,hover,reset,tap,wheel_zoom" , plot_height = 400 , plot_width = 400)
hist, edges = np.histogram(f_list, density=False, normed = True, bins=20)
hist = hist/len(f_list)
cdf=np.cumsum(hist)
plot.quad(top=hist, bottom=0, left=edges[:-1], right=edges[1:] , legend = "pdf")
colors = viridis(len(fold_list))
plot.line(edges[1:], cdf , line_color= "black", line_width= 3 , legend = 'cdf')
#plot.line(edges_pdf[1:], hist_pdf_norm, line_color="red", line_width=3)
vline_list = list()
for i , j in zip(fold_list,colors):
vline = Span(location = i, dimension='height', line_color=j, line_width=3)
vline_list.append(vline)
plot.legend.location = "top_left"
plot.renderers.extend(vline_list)
script, div = components(plot)
#show(plot)
return script, div
def get_question_pie(hotel_id, question):
"""
this function gets hotel_id and question as input and returns pie chart for that questions
answers for that hotel
"""
x = dict(pd.DataFrame({'col1': get_question_answers(hotel_id,question)}).col1.value_counts())
# print(x)
data = pd.Series(x).reset_index(name='value').rename(columns={'index':'answer'})
data['angle'] = data['value']/data['value'].sum() * 2*pi
data['color'] = viridis(len(x))
p = figure(plot_height=250, plot_width = 375, title= question, toolbar_location=None,
tools="hover", tooltips="@answer: @value", x_range=(-0.5, 1.0))
p.wedge(x=0, y=1,radius=0.4,
start_angle=cumsum('angle', include_zero=True), end_angle=cumsum('angle'),
line_color="black", fill_color='color', legend='answer', source=data)
p.axis.axis_label=None
p.axis.visible=False
p.grid.grid_line_color = None
script,div = components(p)
return [script,div]
def printer_double(attrname, old, new):
mesice={'LEDEN':1,'ÚNOR':2,'BŘEZEN':3,'DUBEN':4}
print(mesice_widget.value)
print(region_widget.value)
if (mesice_widget.value==u"VŠE"):
if (region_widget.value!=u"VŠE"): corr_zc_tymy_filtr=corr_zc_tymy[corr_zc_tymy.Region==region_widget.value].copy()
if (mesice_widget.value!=u"VŠE"):
if (region_widget.value!=u"VŠE"): corr_zc_tymy_filtr=corr_zc_tymy[corr_zc_tymy.Region==region_widget.value].loc[(slice(None),[mesice[mesice_widget.value]]), :].copy()
if (mesice_widget.value!=u"VŠE"):
if (region_widget.value==u"VŠE"): corr_zc_tymy_filtr=corr_zc_tymy.loc[(slice(None),[mesice[mesice_widget.value]]), :].copy()
if (mesice_widget.value==u"VŠE"):
if (region_widget.value==u"VŠE"): corr_zc_tymy_filtr=corr_zc_tymy.copy()
data_zc=corr_zc_tymy_filtr["ZC"].tolist()
print(data_zc)
call_colors = viridis(len(remove_dupl(data_zc)))
color_key_value_pairs = list(zip(remove_dupl(data_zc), call_colors))
color_dict = dict(color_key_value_pairs)
colors = [color_dict[x] for x in corr_zc_tymy_filtr['ZC']]
corr_zc_tymy_filtr["color"]=colors
if x_widget.value=='MOJE DATA - SMLOUVY': osa_x="PARTNER"
if x_widget.value=='PLNĚNÍ EE (%)': osa_x="Plnění EE"
if x_widget.value=='PLNĚNÍ EE (ABS)': osa_x="Plnění EE_abs"
if x_widget.value=='SCORE_MEAN': osa_x="score_mean"
if x_widget.value=='SCORE_MIN': osa_x="score_min"
if y_widget.value=='MOJE DATA - SMLOUVY': osa_y="PARTNER"
if y_widget.value=='PLNĚNÍ EE (%)': osa_y="Plnění EE"
if y_widget.value=='PLNĚNÍ EE (ABS)': osa_y="Plnění EE_abs"
if y_widget.value=='SCORE_MEAN': osa_y="score_mean"
if y_widget.value=='SCORE_MIN': osa_y="score_min"
scatter_cds.data = dict(x=corr_zc_tymy_filtr[osa_x],y=corr_zc_tymy_filtr[osa_y],color=corr_zc_tymy_filtr["color"],ZC=corr_zc_tymy_filtr["ZC"],Agent=corr_zc_tymy_filtr["ID agenta/cesty"])
def __init__(self,
df=None,
title=None,
x_title=None,
y_title=None,
x_major_name=None,
x_minor_name=None,
column_display_names=[]):
"""Constructor
Arguments
df: A DataFrame containing the data to be displayed. It is assumed to have
the following columns : Group, Range, Feature, Count, Total Words, per1000
title: A string for the title for the plot
x_title: A string for the X-axis title
y_title: A string for the Y-axis title
x_major_name: A string with the name of the major X axis
x_minor_name: A name for subordinate data series for the X axis if required
column_display_names: The names to be used in the data table display and chart,
replacing the column names in df. Must be ordered in
the same order as the columns in df.
"""
self._df = df
self._title = title
self._x_title = x_title
self._y_title = y_title
self._x_major_name = x_major_name
self._x_minor_name = x_minor_name
self._column_display_names = column_display_names
self._colors = viridis(len(self._df[self._x_minor_name].unique()))
self.sort()
def add_columns_for_pie_chart(df,
column_name,
colors=None,
reverse_color=False,
random_color_order=False):
r = 0.7
df = df.copy()
column_sum = df[column_name].sum()
df['percentage'] = (df[column_name] / column_sum)
percentages = [0] + df['percentage'].cumsum().tolist()
df['starts'] = [p * 2 * pi for p in percentages[:-1]]
df['ends'] = [p * 2 * pi for p in percentages[1:]]
df['middle'] = (df['starts'] + df['ends']) / 2
df['text_x'] = df['middle'].apply(cos) * r
df['text_y'] = df['middle'].apply(sin) * r
df['text_angle'] = 0.0
if colors:
df['colors'] = colors
else:
if 'colors' not in df:
reverse_color = -1 if reverse_color else 1
colors = palettes.viridis(len(df))[::reverse_color]
if random_color_order:
shuffle(colors)
df['colors'] = colors
return df
def plot_counts_by_type(df):
df = df.dropna()
group = df.groupby('PropertyStyle').count().sort_values(by='_Sold',
ascending=False)
curve = hv.Curve(spike_train, 'milliseconds', 'Hertz', group='Firing Rate')
cities = list(group.reset_index().PropertyStyle)
solds = list(group.reset_index()._Sold)
source = ColumnDataSource(
data=dict(cities=cities, solds=solds, color=viridis(len(cities))))
p = figure(x_range=cities,
title="Solds by Styles",
toolbar_location=None,
tools="",
sizing_mode='stretch_both')
p.vbar(x='cities',
top='solds',
width=0.9,
color='color',
legend=None,
source=source)
p.xgrid.grid_line_color = None
p.y_range.start = 0
p.xgrid.grid_line_color = None
p.xaxis.major_label_orientation = 1.2
p.outline_line_color = None
show(p)
def plot_pt(out, labels, lines, **kwargs):
kwargs['plot_height'] = kwargs.get('plot_height',300)
kwargs['plot_width'] = kwargs.get('plot_width',600)
kwargs['x_axis_label'] = kwargs.get('x_axis_label','Temperature (K)')
kwargs['y_axis_label'] = kwargs.get('y_axis_label','Pressure (bars)')
kwargs['x_axis_type'] = kwargs.get('x_axis_type','log')
kwargs['y_axis_type'] = kwargs.get('y_axis_type','log')
cols = viridis(len(out))
ngas = len(out[0]['condensibles'])
mh, mmw = out[0]['scalar_inputs']['mh'], out[0]['scalar_inputs']['mmw']
condensibles = out[0]['condensibles']
pressure = out[0]['pressure']
kwargs['y_range'] = kwargs.get('y_range',[np.max(pressure), np.min(pressure)])
fig = figure(**kwargs)
for i in range(len(out)):
temperature = out[i]['temperature']
pressure = out[i]['pressure']
fig.line(temperature, pressure, legend_label=labels[i], color=cols[i],line_width=5, line_dash=lines[i])
plot_format(fig)
return fig
def test_cmap_generator_function():
assert pal.viridis(256) == pal.Viridis256
assert pal.magma(256) == pal.Magma256
assert pal.plasma(256) == pal.Plasma256
assert pal.inferno(256) == pal.Inferno256
assert pal.gray(256) == pal.Greys256
assert pal.grey(256) == pal.Greys256
def tweet_process(tweet_list):
features = []
for tweet in tweet_list:
features.extend(extract_feature(tweet))
tweet_feature = pandas.DataFrame(features, columns=feature_cols)
topic_vectors = vectorizer.fit_transform(tweet_feature['text'])
similarity = topic_vectors.dot(topic_vectors.transpose())
nonz = similarity.nonzero()
edges = zip(nonz[0], nonz[1], similarity[nonz].flat)
edges_upper = (item for item in edges if item[0] > item[1])
tweet_g = networkx.Graph()
tweet_g.add_weighted_edges_from(edges_upper)
spring_xy = networkx.spring_layout(tweet_g, iterations=50)
tweet_feature['x'] = [0] * len(tweet_feature)
tweet_feature['y'] = [0] * len(tweet_feature)
for node, xy in spring_xy.items():
tweet_feature.loc[node, 'x'] = xy[0]
tweet_feature.loc[node, 'y'] = xy[1]
tweet_feature['color'] = [0] * len(tweet_feature)
maxpop = log(max(tweet_feature['popularity']) + 1, 2)
for i in range(len(tweet_feature)):
tweet_feature.loc[i, 'color'] = viridis(256)[int(
log(tweet_feature.loc[i, 'popularity'] + 1, 2) * 255 / maxpop)]
return tweet_feature
def get_colormapper_add_colorbar(plot, high):
from bokeh.models import (
FixedTicker,
ColorBar,
NumeralTickFormatter,
LinearColorMapper,
)
from bokeh.palettes import viridis
PALETTE_N = 10
palette = viridis(PALETTE_N)
palette.reverse()
color_mapper = LinearColorMapper(palette=palette, low=0, high=high)
ticker = FixedTicker(ticks=[0, high])
formatter = NumeralTickFormatter(format='0 a')
color_bar = ColorBar(
color_mapper=color_mapper,
ticker=ticker,
formatter=formatter,
location=(0, 0),
label_standoff=2,
height=PALETTE_N * 5,
width=10,
major_tick_line_color=None,
major_label_text_align='left',
major_label_text_font=FONT,
)
plot.add_layout(color_bar, 'right')
return color_mapper
def t_merg(self,df,fMT,metal): #(dataframe,fMT,metal)
fig = plt.figure(figsize=(30,30))
ax = [fig.add_subplot(3,3,s) for s in range(1,len(fMT)+1)] #nrows,ncols,index
fig.suptitle('Plots of distribution of time tmerg',fontsize=30)
col = sns.color_palette(palette.viridis(len(metal)))
for i in range(0,len(fMT)):
for j in range(0,len(metal)):
edge = 50*np.logspace(np.log10(df[i][j]['tmerg[11]'].min()), np.log10(df[i][j]['tmerg[11]'].max()), 30)
sns.distplot(df[i][j]['tmerg[11]'],bins=edge,kde=False,norm_hist=True,label=metal[j],
hist_kws={"histtype": "step","lw": 2},ax=ax[i],color=col[j])
ax[i].set_title('Distribution of time tmerg for fMT={}'.format(fMT[i]),fontsize=18)
ax[i].set_xlabel('tmerg [Myr]',fontsize=18)
ax[i].set_ylabel('Density',fontsize=18)
ax[i].legend(title='Metallicity',fontsize=14,title_fontsize=16)
ax[i].tick_params(axis="x", labelsize=16)
ax[i].tick_params(axis="y", labelsize=16)
ax[i].set_xscale('log')
ax[i].set_yscale('log')
ax[i].grid(True, which="both", ls="-",color='0.93')
ax[i].set_axisbelow(True)
if not os.path.isdir('./hist_fMT'):
os.mkdir('./hist_fMT')
plt.savefig('hist_fMT/hist_time_tmerg.pdf', format='pdf')
plt.close()
def mass_chirp(self,df,fMT,metal): #(dataframe,fMT,metal)
fig = plt.figure(figsize=(30,30))
ax = [fig.add_subplot(3,3,s) for s in range(1,len(fMT)+1)] #nrows,ncols,index
fig.suptitle('Plots of distribution of mass mchirp',fontsize=30)
col = sns.color_palette(palette.viridis(len(metal)))
for i in range(0,len(fMT)):
for j in range(0,len(metal)):
# Compute m_chirp
mchirp = np.power( df[i][j]['m1form[8]']*df[i][j]['m2form[10]'], 3/5)/np.power( df[i][j]['m1form[8]']*df[i][j]['m2form[10]'], 1/5)
edge = np.logspace(np.log10(mchirp.min()), np.log10(mchirp.max()), 30)
sns.distplot(mchirp,bins=edge,kde=False,norm_hist=True,label=metal[j],
hist_kws={"histtype": "step","lw": 2},ax=ax[i],color=col[j])
ax[i].set_title('Distribution of mass mchirp for fMT={}'.format(fMT[i]),fontsize=18)
ax[i].set_xlabel('mchirp $[M_\odot]$',fontsize=18)
ax[i].set_ylabel('Density',fontsize=18)
ax[i].legend(title='Metallicity',fontsize=14,title_fontsize=16)
ax[i].tick_params(axis="x", labelsize=16)
ax[i].tick_params(axis="y", labelsize=16)
ax[i].set_xscale('log')
ax[i].grid(True, which="both", ls="-",color='0.93')
ax[i].set_axisbelow(True)
if not os.path.isdir('./hist_fMT'):
os.mkdir('./hist_fMT')
plt.savefig('hist_fMT/hist_mass_chirp.pdf', format='pdf')
plt.close()
def assignColors(arr, maxval, minval, bins=10):
"""
Assign colors with a logarithmic increment using Bokeh's virids palette
colors lower than bins are grey and above are max.
input:
arr: list of values
maxval: Maximum value for color assignment
minval: Minimum value for color assignment
bins: Number of increments
output:
arr_colors: Color assigned for each color
"""
# Create a list of colors for increments
colors = viridis(bins)
# Create the increments between max and min on a log10 scale
bin_ranges = np.logspace(minval, maxval, bins)
arr_colors = []
for val in arr:
if val == 0:
arr_colors.append('grey')
elif val > bin_ranges[-1]:
arr_colors.append(colors[-1])
else:
for i in range(len(bin_ranges)):
if val < bin_ranges[i]:
arr_colors.append(colors[i])
break
return arr_colors
def q(self,df,fMT,metal): #(dataframe,fMT,metal)
fig = plt.figure(figsize=(30,30))
ax = [fig.add_subplot(3,3,s) for s in range(1,len(fMT)+1)] #nrows,ncols,index
fig.suptitle('Plots of distribution of q',fontsize=30)
col = sns.color_palette(palette.viridis(len(metal)))
for i in range(0,len(fMT)):
for j in range(0,len(metal)):
# Compute q
q = df[i][j]['m2form[10]']/df[i][j]['m1form[8]']
sns.distplot(q,kde=False,norm_hist=True,label=metal[j],
hist_kws={"histtype": "step","lw": 2},ax=ax[i],color=col[j])
ax[i].set_title('Distribution of q for fMT={}'.format(fMT[i]),fontsize=18)
ax[i].set_xlabel('q',fontsize=18)
ax[i].set_ylabel('Density',fontsize=18)
ax[i].legend(title='Metallicity',fontsize=14,title_fontsize=16,loc='upper left')
ax[i].tick_params(axis="x", labelsize=16)
ax[i].tick_params(axis="y", labelsize=16)
ax[i].grid(True, which="both", ls="-",color='0.93')
ax[i].set_axisbelow(True)
if not os.path.isdir('./hist_fMT'):
os.mkdir('./hist_fMT')
plt.savefig('hist_fMT/hist_q.pdf', format='pdf')
plt.close()
def get_layout(json_data, filters):
sql_data = json_to_sql(json_data, filters)
data = get_dataframe(sql_data)
labels = get_plot_labels(json_data)
columns = data.columns.tolist()
columns.remove('x')
x_axis_data = [(x, z) for x in data['x'] for z in columns]
to_zip = [data[c].tolist() for c in columns]
y_axis_data = sum(zip(*to_zip), ())
source = ColumnDataSource(
data=dict(x_axis_data=x_axis_data, y_axis_data=y_axis_data))
hover = HoverTool(tooltips=[
(','.join(labels.x_label.rsplit('-', 1)[::-1]), "@x_axis_data"),
(labels.y_label, "@y_axis_data"),
])
p = figure(x_range=FactorRange(*x_axis_data),
plot_width=1200,
plot_height=600,
title=labels.title,
tools=[hover, 'pan', 'box_zoom', 'wheel_zoom', 'save', 'reset'])
p.vbar(x='x_axis_data',
top='y_axis_data',
width=1,
source=source,
line_color="white",
fill_color=factor_cmap('x_axis_data',
palette=viridis(len(columns)),
factors=columns,
start=1,
end=len(columns)))
p.y_range.start = 0
p.x_range.range_padding = 0.1
p.xaxis.major_label_orientation = 1
p.xgrid.grid_line_color = None
p.xaxis.axis_label = labels.x_label
p.yaxis.axis_label = labels.y_label
p.title.align = 'center'
# eng = TextInput(title="ENG")
# tran = TextInput(title="TRAN")
# miles = TextInput(title="MILES")
#
# controls = [eng, tran, miles]
#
# sizing_mode = 'fixed'
#
# ly = layout([controls, [p]], sizing_mode=sizing_mode)
# return ly
return p
def plottrends():
x = range(pf.MonthsImported)
yforplot = port.marketdatas[0].pricehistory
#img = imread('worldmap-background-design_1127-2318.jpg')
# create a new plot with a title and axis labels
p = figure(title='Assets time series data. Source: Quandl.com', \
x_axis_label='x', y_axis_label='y')
# add a line renderer with legend and line thickness
mypalette = viridis(port.nrassets)
#print(len(mypalette))
for i in range(port.nrassets):
#print(i)
p.line(range(-port.marketdatas[i].lenpricehistory + 1,1), port.marketdatas[i].pricehistory*100.0, \
legend=port.marketdatas[i].name, line_color = mypalette[i], \
line_width=2)
p.legend.location = "top_left"
#p.height = 100
#p.width = 100
p.xaxis.axis_label = 'Time (months before T0)'
p.yaxis.axis_label = 'Return (USD when each market index starts at USD 100)'
plot = p
script, div = components(plot)
return render_template('plottrends.html', script = script, div = div, \
inittext='')
def percentage_error_plot(y_true, y_pred, y_bench):
"""
Given the true value and the predicted value, it computes the
"""
TOOLS = 'pan,wheel_zoom,box_zoom,reset,save,box_select,crosshair'
hover = HoverTool(tooltips=[
("Error pct", '$y'),
])
list_symbols = list(y_true.columns)
p = figure(width=900,
height=500,
x_axis_type="datetime",
tools=[TOOLS, hover])
p.legend.location = "top_left"
p.xaxis.axis_label = 'Date'
p.yaxis.axis_label = 'Error percentage'
p.title.text = "Error percentage for %s ticker symbols" % (
", ".join(list_symbols))
colors = viridis(len(list_symbols))
for (i, sym) in enumerate(list_symbols):
p.line(y_true.index, (y_true[sym] - y_pred[sym]) / y_true[sym] * 100,
legend=sym,
line_width=2,
color=colors[i])
#p.line(y_true.index,(y_true[sym]-y_bench[sym])/y_true[sym]*100,line_width=2,legend='Bench_'+sym,color=colors[i],line_dash='dashed')
tab = Panel(child=p, title='Error percentage')
return tab
def update_graph(jobs_db, graph_path):
rows = []
for job in jobs_db.all():
rows.append([
job.get("<project_code>"),
job.get("<command>"),
job.get(">start_time"),
job.get("timeout")
])
df = pd.DataFrame(rows, columns=["project", "command", "start", "timeout"])
df = df.sort_values(by="project", ascending=False)
df["start"] = pd.to_datetime(df["start"], format="%H:%M:%S")
df["start_txt"] = df.start.astype("str").str.extract(r"(\d+:\d+)",
expand=True) + " h"
df["timeout_txt"] = df['timeout'].copy().astype('str') + " seconds"
df["timeout"] = df['timeout'].astype('timedelta64[s]')
df["end"] = pd.to_datetime(df["start"], format="%H:%M:%S") + df["timeout"]
colors = viridis(len(df["project"]))
output_file(graph_path, title="rvt_model_services_jobs", mode="inline")
cds = ColumnDataSource(data=dict(
start=df["start"].values,
end=df["end"].values,
name=df["project"],
timeout=df["timeout_txt"],
start_txt=df["start_txt"],
command=df["command"],
color=colors,
))
hover = HoverTool(tooltips=[
("project", "@name"),
("command", "@command"),
("start time:", "@start_txt"),
("timeout:", "@timeout"),
])
tools_opt = [hover, "save", "pan", "wheel_zoom", "box_zoom", "reset"]
graph_opt = dict(width=900,
x_axis_type="datetime",
tools=tools_opt,
toolbar_location="right",
background_fill_alpha=0,
border_fill_alpha=0)
jobs_viz = figure(title="rvt_model_service_jobs",
y_range=list(df["project"].unique()),
**graph_opt)
jobs_viz.hbar(
source=cds,
y="name",
left="start",
right="end",
height=1,
color="color",
)
style_plot(jobs_viz)
save(jobs_viz)
def get_multi_line_plot(self, df: pd.DataFrame, width, height, title):
"""
This function design a plot with the structure of Parallel Coordinates graph.
For that, it uses the function multi_line from bokeh module. And then, it calls the
function add_annotation_for_categorical_data in order to add a label where there are the code-category
from the categorical data
:param df: Data frame which we want to plot
:param width: The width measure for the figure
:param height: The height measure for the figure
:param title: The tittle for the figure
:return: The corresponding plot completed
"""
plot = bk.figure(plot_width=width,
plot_height=height,
title=title,
x_range=list(self.my_df))
ys_list = list()
xs_list = list()
for i in range(0, len(df)):
aux_ys_list = df.iloc[i].tolist()
ys_list.append(aux_ys_list.copy())
xs_list.append(list(range(0, len(df.columns))))
try:
my_palette = viridis(len(df.index))
plot.multi_line(xs=xs_list, ys=ys_list, line_color=my_palette)
except ValueError:
plot.multi_line(xs=xs_list, ys=ys_list)
plot.xaxis.major_tick_line_color = None
plot.xgrid.visible = False
plot.ygrid.visible = False
TextAlign = enumeration("left", "right", "center")
plot.xaxis.major_label_text_align = TextAlign.left
plot.xaxis.major_label_orientation = pi / 6
plot = self.add_annotation_for_categorical_data(plot, width)
return plot
def colorby(values):
if not values.dtype == int:
values = [values.unique().tolist().index(v) for v in values]
v = viridis(max(values)+1)
color = [v[c] for c in values]
return color
def _get_categorical_palette(factors: List[str]) -> Dict[str, str]:
n = max(3, len(factors))
if n < len(palette):
_palette = palette
elif n < 21:
from bokeh.palettes import Category20
_palette = Category20[n]
else:
from bokeh.palettes import viridis
_palette = viridis(n)
return CategoricalColorMapper(factors=factors, palette=_palette)
def colorPalette(self, size=None):
# https://bokeh.pydata.org/en/latest/docs/reference/palettes.html
# https://bokeh.pydata.org/en/latest/docs/reference/colors.html
color = list(d3['Category10'][10]) # [ 'orangered', 'cornflowerblue', ]
# color = list(Spectral9).reverse()
if size is None:
return color
elif size <= len(color):
return color[0:size]
elif size <= 256:
return linear_palette(plasma(256), size)
else:
return linear_palette(plasma(256) + viridis(256) + magma(256), size)
def map_color(arr: [], base_color=None, color_res=256, satur=False) -> "":
min_a, max_a = (min(arr), max(arr))
def get_num_col_index(num):
return int(round((num - min_a) / (max_a - min_a) * (color_res - 1)))
arr_n = [get_num_col_index(c) for c in arr]
if base_color:
if satur:
color_ramp_int = create_s_ramp_by_color(color_res, base_color)
else:
color_ramp_int = create_l_ramp_by_color(color_res, base_color)
color_ramp = [int2hex(c) for c in color_ramp_int]
else:
color_ramp = palettes.viridis(color_res)
arr_colors = [color_ramp[i] for i in arr_n]
return arr_colors
def init_grid(self,
range_min = -1,
range_max = 1):
'Create an empty sample. '
self.converged= False
# Initialization
self.range_min = range_min
self.range_max = range_max
# If the algorithm doesn't converge, just return the best point so far.
self.widen_attempts = 0
self.active_min = float(self.range_min)
self.active_max = float(self.range_max)
# tuples of (x, f(x)), ordered by x.
self.search_grid = []
# tuples of current estimate & residual avg error,
self.residuals = []
# Also assign plotting colors to points
self.colors_grid = []
self.iseq = 0 # Color index
self.spectrum = viridis(self.CLR_CYCLE) # colors to cycle thru.
self.spectrum.reverse()
self.x = []
self.y = []
self.half_range = (self.range_max - self.range_min)/2
def test_cmap_generator_function():
assert viridis(10) == Viridis10
d['released-loc'] = []
d['memory-loc'] = []
d['erred-loc'] = []
d['done'] = []
for r, m, e, a, l in zip(d['released'], d['memory'],
d['erred'], d['all'], d['left']):
rl = width * r / a + l
ml = width * (r + m) / a + l
el = width * (r + m + e) / a + l
done = '%d / %d' % (r + m + e, a)
d['released-loc'].append(rl)
d['memory-loc'].append(ml)
d['erred-loc'].append(el)
d['done'].append(done)
return d
from toolz import memoize
from bokeh.palettes import Spectral11, Spectral9, viridis
import random
task_stream_palette = list(viridis(25))
random.shuffle(task_stream_palette)
import itertools
counter = itertools.count()
@memoize
def incrementing_index(o):
return next(counter)
