def plot_asweep(df, plot_stress=False):
"""
Function to plot amplitude sweeps
ARGS :
- df [PANDAS.DATAFRAME] : your sliced rheology data
- steps [LIST] : your step(s) you want to plot (can be only one step)
OUTPUT :
- a figure (d'uh !)
"""
steps = np.unique(df['step'])
f1 = figure(x_axis_type='log',
y_axis_type='log',
title='Amplitude Sweep',
tooltips=[('x', '$x'), ('y', '$y')])
cmap, cmap_line = magma(np.size(steps)), _darken(magma(np.size(steps)))
for no, step in enumerate(steps):
# Check that step makes sense
amp_sweep = df[df['step'] == step]
if amp_sweep.iloc[0]['steptype'] != 'Amplitudesweep':
print('plot_asweep > Warning : Cannot confirm that step ' +
str(step) + ' is an amplitude sweep')
f1.scatter(x='strain',
y='gprime',
marker='square',
line_color=cmap[no],
fill_color=cmap_line[no],
source=amp_sweep,
legend_label="G' , step " + str(step))
f1.scatter(x='strain',
y='gsecond',
marker='o',
line_color=cmap[no],
fill_color='white',
source=amp_sweep,
legend_label="G'' , step " + str(step))
if plot_stress:
f1.scatter(x='strain',
y='stress',
marker='triangle',
line_color=cmap_line[no],
fill_color=cmap[no],
source=amp_sweep,
legend_label='σ , step ' + str(step))
f1.xaxis.axis_label, f1.yaxis.axis_label = 'γ (%)', 'G, σ (Pa)'
f1.legend.location = "bottom"
show(f1)
time.sleep(0.5)
return f1
def plot_tsweep(df, plot_stress=False):
"""
Function to plot time sweeps
ARGS :
- df [PANDAS.DATAFRAME] : your sliced rheology data
- plot_stress [BOOL] [OPTIONAL] : add the global oscillatory stress to the plot
OUTPUT :
- a figure (d'uh !)
"""
steps = np.unique(df['step'])
f1 = figure(x_axis_type='log',
y_axis_type='log',
title='Time Sweep',
tooltips=[('x', '$x'), ('y', '$y')])
cmap, cmap_line = magma(np.size(steps)), _darken(magma(np.size(steps)))
for no, step in enumerate(steps):
# Check that step makes sense
time_sweep = df[df['step'] == step]
if time_sweep.iloc[0]['steptype'] != 'Timesweep':
print('plot_tsweep > Cannot confirm that step ' + str(step) +
' is a time sweep')
f1.scatter(x='time',
y='gprime',
marker='square',
line_color=cmap_line[no],
fill_color=cmap[no],
source=time_sweep,
legend_label="G' , step " + str(step))
f1.scatter(x='time',
y='gsecond',
marker='o',
line_color=cmap_line[no],
fill_color='white',
source=time_sweep,
legend_label="G'' , step " + str(step))
if plot_stress:
f1.scatter(x='frequency',
y='stress',
marker='triangle',
line_color=cmap_line[no],
fill_color=cmap[no],
source=time_sweep,
legend_label='σ , step ' + str(step))
f1.xaxis.axis_label, f1.yaxis.axis_label = 't (s)', 'G, σ (Pa)'
f1.legend.location = "left"
show(f1)
time.sleep(0.5)
return f1
def plot_flowcurve(df, fit_up_to=500):
"""
Function to plot flow curve steps
ARGS :
- df [PANDAS.DATAFRAME] : your sliced rheology data
- fit_up_to [FLOAT] [OPTIONAL] : fit the flow curves up to some specific shear rate value
OUTPUT :
- a figure (d'uh !)
- FIT [Nx4 list] : the fit to your steps, with [step, sigma_Y, K, exponent]
"""
steps = np.unique(df['step'])
fits_all = np.zeros((len(steps), 4))
# Create and format figure
f1 = figure(x_axis_type='log',
y_axis_type='log',
title='Flow Curve',
tooltips=[('x', '$x'), ('y', '$y')])
f1.xaxis.axis_label, f1.yaxis.axis_label = 'γ (1/s)', 'τ (Pa)'
cmap, cmap_line = magma(np.size(steps)), _darken(magma(np.size(steps)))
for no, step in enumerate(steps):
# Check that step makes sense
flow_curve = df[df['step'] == step]
if flow_curve.iloc[0]['steptype'] != 'Flowcurve':
print('plot_flowcurve > Warning : Cannot confirm that step ' +
str(step) + ' is a flow curve.')
ys, K, exponent = _fit_HB(flow_curve['shearrate'],
flow_curve['stress'],
fit_up_to=fit_up_to)
fits_all[no, :] = [step, ys, K, exponent]
# Plotting + Display + producing the fitted curve
shearrates = flow_curve['shearrate']
fitted_stress = ys + K * shearrates**exponent
f1.line(shearrates, fitted_stress, line_color=cmap[no])
f1.scatter(x='shearrate',
y='stress',
marker='square',
source=flow_curve,
line_color=cmap_line[no],
fill_color=cmap[no],
legend_label="Flow curve, step " + str(step))
print('plot_flowcurve > fit for step ' + str(step) + ' : τ = ' +
'{:3.2f}'.format(ys) + ' + ' + '{:3.2f}'.format(K) + ' γ^(' +
'{:3.2f}'.format(exponent) + ')')
show(f1)
time.sleep(0.5)
return fits_all, f1
def update_colors(self, use_gradient):
if use_gradient:
mx = np.max(self.display_df['total'])
if mx > 1:
mx = np.ceil(10 * np.log2(mx)) / 10
if not np.isnan(mx):
self.display_df['color'] = [
magma(256)[int(np.log2(tot) * 255 / mx)]
for tot in self.display_df['total']
]
else:
self.display_df['color'] = magma(4)[0]
if self.built:
self.source.data = self.display_df.to_dict(orient='list')
def plot_normalforce(df):
"""
Function to plot flow normal forces (as a function of gamma_dot by default, but gamma also possible)
ARGS :
- df [PANDAS.DATAFRAME] : your sliced rheology data
- steps [LIST] : your step(s) you want to plot (can be only one step)
OUTPUT :
- a figure (d'uh !)
"""
steps = np.unique(df['step'])
# Create and format figure
f1 = figure(x_axis_type='log',
y_axis_type='linear',
title='Normal Force',
tooltips=[('x', '$x'), ('y', '$y')])
f1.y_range.start, f1.y_range.end = -1, 1
cmap, cmap_line = magma(np.size(steps)), _darken(magma(np.size(steps)))
for no, step in enumerate(steps):
# Check that step makes sense
df_now = df[df['step'] == step]
if df_now.iloc[0]['steptype'] == 'Flowcurve':
print('plot_normalforce > Step ' + str(step) +
' is a flow curve. Plotting N = f(gamma_dot)')
f1.scatter(df_now['shearrate'],
df_now['normalforce'],
line_color=cmap_line[no],
fill_color=cmap[no],
marker='o',
legend_label='Step ' + str(step))
f1.xaxis.axis_label, f1.yaxis.axis_label = 'γ^dot (1/s)', 'F_N (N)'
else:
print('plot_normalforce > Step ' + str(step) +
' not a flow curve. Plotting N = f(gamma)')
f1.scatter(df_now['strain'],
df_now['normalforce'],
line_color=cmap[no],
fill_color=cmap[no],
marker='diamond',
legend_label='Step ' + str(step))
f1.xaxis.axis_label, f1.yaxis.axis_label = 'γ (1)', 'F_N (N)'
show(f1)
time.sleep(0.5)
return f1
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 make_dataset(Music):
#con = sql.connect('/Users/aaronwestmoreland/Documents/Data.Projects/Music/Metacritic.db')
#Music = psql.read_sql('SELECT * FROM Music;', con)
Mus_split = Music["Day"].str.split(' ', expand=True)
Music["Month"] = Mus_split[0]
Music["Date"] = Mus_split[1]
c_map = bp.magma(len(np.unique(Music["Score"])))
c_dict = zip(np.unique(Music["Score"]), c_map)
Col_MAP = dict(c_dict)
Music["color"] = Music["Score"].apply(lambda x: Col_MAP[x])
#Music["Month"]
Music["DateTime"] = pd.to_datetime(Music["Release"],
format="%b %d, %Y")
Music['alpha'] = np.where(Music["Score"].astype(float) >= 90, 0.9,
0.25)
mu_dict = dict(
x=Music["Release"],
y=Music["Score"].astype(float),
album=Music["Album"],
release=Music["Release"],
artist=Music["Artist"],
alpha=Music["alpha"],
color=Music['color'],
)
return ColumnDataSource(mu_dict)
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 bar(x, y, x_label, y_label,bar_width):
plot = figure(x_range = x,
title = y_label + ' vs. ' + x_label,
plot_width = 600,
plot_height = 600)
plot.vbar(x = x, top = y, width = bar_width, color = palettes.magma(len(x)))
return components(plot)
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
assert pal.turbo(256) == pal.Turbo256
assert pal.diverging_palette(pal.Reds9, pal.Greys9, n=18, midpoint=0.5) == pal.Reds9 + pal.Greys9[::-1]
def create_kw_freq_bar_graphs(raw_dataframe,
start_date=0,
end_date=0,
freq_threshold=3):
"""
Creates a keyword frequency bar graph from dataframe and exports it in html with name of newspaper and creation
timestamp
Default keyword frequency threshold set at 3
Can select time scope with start_date and end_date variables, if not set defaults to include all given data
"""
# Slicing Dataframe to begin at start_date
if start_date == 0:
start_date = raw_dataframe['Datetime'].min()
else:
start_date = start_date
raw_dataframe = raw_dataframe[raw_dataframe['Datetime'] >= start_date]
# Slicing Dataframe to end at end_date
if end_date == 0:
end_date = raw_dataframe['Datetime'].min()
else:
end_date = end_date
raw_dataframe = raw_dataframe[raw_dataframe['Datetime'] <= end_date]
newspapers = raw_dataframe['Newspaper'].unique().tolist()
for np_name in newspapers:
df = create_keyword_ranking_df(
raw_dataframe[raw_dataframe['Newspaper'] == np_name],
freq_threshold)
# Creating figure
p1 = figure(title=f'Keyword ranking {np_name}',
x_range=df['keyword'],
width=1000,
height=300,
sizing_mode='scale_width')
# Setting axis names and properties
p1.xaxis.major_label_orientation = 4 / 3
p1.yaxis.axis_label = 'Frequency'
p1.xaxis.axis_label = 'Keyword'
p1.xaxis.axis_label_text_font_size = '18pt'
palette = magma(len(df))
# Creating bar elements
p1.vbar(x=df['keyword'],
top=df['frequency'],
width=0.5,
fill_color=palette,
line_color='black')
# Adding hover tools
p1.add_tools(HoverTool(tooltips=[('Count', '@top{0}')]))
# Setting file name and path
filename = f'Kw_freq_{np_name.lower()}_{start_date}_to_{end_date}.html'
path = 'html_graphs/' + filename
html = file_html(p1, CDN, 'kw_frequency_plot')
with open(path, 'w+') as file:
file.write(html)
def default_palette(self):
from bokeh import palettes
palette_options = {
'viridis': palettes.viridis(256),
'magma': palettes.magma(256),
'coolwarm': cc.coolwarm,
}
return palette_options[self.settings.get('palette', 'viridis')]
def plot_startup(df, reversal=False, malvern=True):
"""
Function that helps plot shear startup and reversals
ARGS :
- df [PANDAS.DATAFRAME] : your sliced rheology data
- reversal [BOOL] [DEFAULT : FALSE] : bunch your startup data two-by-two and
consider that every odd (even) step is forward (reverse) done consecutively
- malvern [BOOL] [DEFAULT : TRUE] : specify this to avoid issues with the shear
stress not being negative during shear reversal tests.
OUTPUT :
- a figure (d'uh !)
"""
f1 = figure(title='Shear Startup / Reversal')
steps = np.unique(df['step'])
strain_offset = np.zeros(len(steps) + 1)
cmap = magma(np.size(steps))
# Fix things that are messed up first ...
if reversal:
steps_forward = steps[::2]
steps_reverse = steps[1::2]
if malvern:
df = fix_stress_malvern_reversal(df, steps_reverse)
else:
df = fix_strain_antonpaar(df, steps)
else:
steps_forward = steps
# Plot things, be careful with strain offsets
for no, s in enumerate(steps):
strain, stress = df[df['step'] == s]['strain'], df[df['step'] ==
s]['stress']
avgrate = np.mean(df[df['step'] == s]['shearrate'])
if s in steps_forward and reversal: # No need for strain offsets if no reversal ...
strain_offset[no + 1] = df[df['step'] == s]['strain'].iloc[-1]
f1.line(strain + strain_offset[no],
stress,
line_color=cmap[no],
line_width=1,
legend_label='gdot = ' + '{:3.2e}'.format(avgrate))
strslim, strnlim = np.max(np.abs(df['stress'])), np.max(
np.abs(df['strain']))
f1.line([0, strnlim], [0, 0], line_dash='dotted', line_color='black')
f1.line([strnlim / 2, strnlim / 2], [-strslim, strslim],
line_dash='dotted',
line_color='black')
f1.xaxis.axis_label, f1.yaxis.axis_label = 'gamma (%)', 'sigma (Pa)'
show(f1)
return f1
def prepare_plots3(target_vals,epoch, METRICSPATH):
cfm_file = f"{METRICSPATH}/confusion-{epoch}.png"
bok_file = f"{METRICSPATH}/ranking_{epoch}.html"
classes, rankings, preds, pred_rank = [],[],[],[]
for t_ in target_vals:
cl_,ra_,pr_,em_ = t_
classes.append(cl_)
rankings.append(ra_)
preds.append(pr_)
pred_rank.append(em_)
classes = np.squeeze(np.concatenate(classes))
rankings = np.squeeze(np.concatenate(rankings))
predictions = np.concatenate([softmax(p,axis=0) for p in preds])
pred_rank = np.concatenate(pred_rank)
activations = np.argmax(predictions,axis=1)
conf_mat = confusion_matrix(classes,activations)
fig = plt.figure(figsize=[10,8])
plot_confusion_matrix(conf_mat, classes=class_names, normalize=False,
title=f'Confusion matrix epoch {epoch}')
plt.savefig(cfm_file,format="png")
pil_image = fig2pil(fig)
neptune.send_image('conf_mat', pil_image)
df = pd.DataFrame(data={ 'tar': rankings, 'pred': pred_rank, 'class': classes})
palette = magma(num_of_classes + 1)
p = figure(plot_width=600, plot_height=800, title=f"Ranking by exercise, epoch {epoch}")
p.xgrid.grid_line_color = None
p.xaxis.axis_label = 'Target ranking'
p.yaxis.axis_label = 'Predicted ranking'
for cl in range(num_of_classes):
if cl == 6:
continue
df2 = df.loc[df['class']==cl]
p.circle(x=jitter('tar',0.3), y='pred', size=8, alpha=0.1, color=palette[cl], legend=class_names[cl], source=df2 )
p.line(x='tar', y='pred', line_width=2, alpha=0.5, color=palette[cl],legend=class_names[cl], source=df2.groupby(by="tar").mean())
p.legend.location = "top_left"
p.legend.click_policy="hide"
output_file(bok_file, title="Ranking by exercise")
save(p)
pil_image2 = get_screenshot_as_png(p)
neptune.send_image('rank_distances', pil_image2)
def make_earning_plot(data, symbol=''):
num_of_year = len(data['year'].unique())
colors = magma(num_of_year)
mapper = LinearColorMapper(palette=colors,
low=data.year.max(),
high=data.year.min())
source = ColumnDataSource(data)
plot = figure(
x_range=Range1d(0, 5),
plot_height=500,
plot_width=1000,
)
reported = plot.circle(
x='quarter',
y='reported',
source=source,
name='reported',
legend='Reported',
size=20,
color=transform('year', mapper),
fill_color=transform('year', mapper),
)
estimated = plot.circle(
x='quarter',
y='estimate',
source=source,
name='estimated',
legend='Estimated',
size=15,
color=transform('year', mapper),
fill_alpha=0.4,
muted_alpha=0.1,
)
price_hover = HoverTool(renderers=[reported],
tooltips=[
("year: ", "@year"),
("reported: ", "@reported"),
("estimate: ", "@estimate"),
("surprise: ", "@surprise{0.2f}"),
("surprise_per: ", "@surprise_per"),
])
plot.add_tools(price_hover)
plot.title.text = f"{symbol.upper()} Earning" if symbol else "Earning"
plot.legend.location = "top_left"
plot.xaxis.axis_label = 'Quarter'
plot.yaxis.axis_label = 'Price'
plot.ygrid.band_fill_color = "olive"
plot.ygrid.band_fill_alpha = 0.1
plot.legend.click_policy = "mute"
plot.xaxis.ticker = [1, 2, 3, 4]
return plot
def genColors(n, ptype='magma'):
"""
"""
from bokeh.palettes import magma, inferno, plasma, viridis
if ptype == 'magma':
return magma(n)
elif ptype == 'inferno':
return inferno(n)
elif ptype == 'plasma':
return plasma(n)
else:
return viridis(n)
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 get_colormap(num_of_items):
"""
Project: 'ICOS Carbon Portal'
Created: Fri Apr 04 17:00:00 2019
Last Changed: Fri Apr 04 17:00:00 2019
Version: 1.0.0
Author(s): Karolina Pantazatou
Description: Function that takes an integer representing the total number of
items that should receive a sepparate color and returns a colormap
(i.e. a list of strings, where every string represents a different
color in hexadecimal code) with the same amount of colors.
The function uses color palettes (namely Colorblind & magma) from
the Bokeh visualization library and can return colormaps for
1 - 256 items.
Input parameters: Number of items to be colored in a sepparate color
(var_name: 'num_of_items', var_type: Integer)
Output: List of strings (colormap)
"""
#Check input:
if (isinstance(num_of_items, int)):
#import module:
from bokeh.palettes import all_palettes, Colorblind, magma
#Check the number of items to be colored (1-2 items):
if ((num_of_items > 0) and (num_of_items < 3)):
return ['#2b83ba', '#fdae61'] #return colormap selection
#Check the number of items to be colored (3-8 items):
elif ((num_of_items > 2) and (num_of_items < 9)):
return all_palettes['Colorblind'][
num_of_items] #return colormap selection
#Check the number of items to be colored (9-256 items):
elif ((num_of_items > 8) and (num_of_items < 257)):
return magma(num_of_items) #return colormap selection
#If the number of items exceeds the number 256:
else:
print(
'Error! Number of items to be colored is zero or higher than 256.'
)
#If the input parameter is not an integer:
else:
print('Input is not an integer.')
def plot_creep(df, x_axis_type='log', y_axis_type='log', plot_shearrate=False):
"""
Function that plots creep data
ARGS :
- df [PANDAS.DATAFRAME] : your sliced rheology data
- y_axis_type [STR] [DEFAULT : 'log'] : whether y axis is log or lin
- x_axis_type [STR] [DEFAULT : 'log'] : whether x axis is log or lin
- plot_shearrate [BOOL] [DEFAULT : False] : whether to plot gamma dot instead of gamma
OUTPUT :
- a figure (d'uh !)
"""
f1 = figure(title='Creep',
x_axis_type=x_axis_type,
y_axis_type=y_axis_type)
steps = np.unique(df['step'])
cmap = magma(np.size(steps))
for no, cr in enumerate(steps):
strn = df.loc[df['step'] == cr, 'strain']
sr = df.loc[df['step'] == cr, 'shearrate']
tm = df.loc[df['step'] == cr, 'time']
strs = df.loc[df['step'] == cr, 'stress'].to_numpy().mean()
if plot_shearrate:
f1.line(tm,
sr,
line_color=cmap[no],
line_width=1,
legend_label='Step ' + str(cr) + ', sigma = ' +
'{:4.2f}'.format(strs) + ' Pa')
f1.yaxis.axis_label = 'gamma^dot (1/s)'
f1.legend.location = 'bottom_left'
else:
f1.line(tm,
strn,
line_color=cmap[no],
line_width=1,
legend_label='Step ' + str(cr) + ', sigma = ' +
'{:4.2f}'.format(strs) + ' Pa')
f1.line([1e-3, np.max(strn)], [1e-3, np.max(strn)],
line_dash='dotted',
line_color='black')
f1.yaxis.axis_label = 'gamma (%)'
f1.legend.location = 'top_left'
f1.xaxis.axis_label = 'time (s)'
show(f1)
return f1
def create_figure(n):
mass_spec = defaultdict(list)
int_fict = np.arange(50)
order_loc = np.ones(50)
n = int(n)
choices = ['Todos', 'Ninguno', 'Retroexcavdora, Camion']
lista_zonas = [(1.0, 'Zona ' + str(k), np.random.choice(choices))
for k in range(n)]
for scale, mz, evt_list in lista_zonas:
mass_spec["RT"].append(order_loc)
order_loc = order_loc + 1
mass_spec["RT_intensity"].append(int_fict *
scale) #norm(loc=120.4).pdf(RT_x) *
mass_spec['Eventos_permitidos'].append(evt_list)
mass_spec['Intensity_tip'].append(mz)
mass_spec['rel_int'].append(np.random.normal(loc=0.9, scale=0.01))
mass_spec['color'] = magma(n)
source = ColumnDataSource(mass_spec)
x_limit_left = n + 0.1
p = figure(plot_width=800, plot_height=600, x_range=(0, x_limit_left))
hover_t = HoverTool(show_arrow=False,
tooltips=[('Eventos permitidos',
'@Eventos_permitidos'),
('Intensidad relativa', '@rel_int')])
p.add_tools(hover_t)
p.image_url(url=['static/mapa.png'],
x=0,
y=0,
w=x_limit_left,
h=49,
anchor='bottom_left')
ml = p.multi_line(xs='RT',
ys='RT_intensity',
legend="Intensity_tip",
line_width=5,
line_color='color',
line_alpha=0.6,
hover_line_color='pink',
hover_line_alpha=1.0,
source=source)
p.xaxis.bounds = (0, n)
p.yaxis.visible = False
return p
def aggregate(self):
agg = self.df.groupby(['F', 'A']).agg(['count', 'max', 'min'])
self.display_df = pd.DataFrame({
'F': agg['fer']['max'],
'A': agg['agin']['min'],
'total': agg['fer']['count']
})
date_strings = [
generate_tooltip_data(x)
for x in zip(agg['Date']['min'], agg['Date']['max'])
]
self.display_df['first'] = [x[0] for x in date_strings]
self.display_df['last'] = [x[1] for x in date_strings]
self.display_df['color'] = magma(4)[0]
def get_color(min_val, max_val, n, val):
'''
Gets the background and text color for rendering a cell with value val in a
matrix with n values and min and max values min_val and max_val,
respectively.
Args:
min_val (float) Smallest value in the matrix.
max_val (float) Largest value in the matrix.
n (int) Number of values in the matrix.
val (float|int) Value of cell in question.
Returns:
(str, str) The background and text color
'''
# The result should be memoized so we don't have to keep computing the full
# range of values, but oh well. Choose from: magma, inferno, plasma,
# viridis.
top = float(max_val - min_val)
black = magma(2)[0]
white = 'white'
# If the matrix is basically all the same value just return black.
if np.isclose(0.0, top):
return black, white
# Compute which color to return.
idx = int(((val - min_val) / top) * n)
bg_color = magma(n + 1)[idx]
text_color = white
# This is specific to magma. To make the text more readable, change its
# color to black if we're more than 90% of the way through the magma
# colors.
if ALL_MAGMA.index(bg_color) >= 0.9 * len(ALL_MAGMA):
text_color = black
return bg_color, text_color
def make_data(dist, cat):
df_distcat = df_data[(df_data['PdDistrict'].isin(dist))
& (df_data['Category'].isin(cat))]
df_grouped = df_distcat.groupby('DayOfWeek')[['PdId']].count().sort_values(
'PdId', ascending=False)
df_hour_dist = df_distcat.groupby([df_distcat.index.hour, 'PdDistrict'
])['PdId'].count().unstack()
bar_palette = magma(len(df_grouped))
bar_source = ColumnDataSource(
dict(x=df_grouped.index.tolist(),
top=df_grouped['PdId'],
color=bar_palette))
numlines = df_hour_dist.shape[1]
line_source = ColumnDataSource(
dict(x=[df_hour_dist.index.values] * numlines,
y=[df_hour_dist[name].values for name in df_hour_dist],
color=magma(numlines),
label=[name for name in df_hour_dist]))
return bar_source, line_source
def plot_control_startup(df, malvern=True, strain_as_x=True):
"""
A companion function to check if your shear startup / reversals make sense
Plots the strain rate as a function of time. Since I don't have the target
I can't do just an "error plot"
ARGS :
- df [PANDAS.DATAFRAME] : your sliced rheology data. Note : you need to run "
OUTPUT :
- a figure (d'uh !)
"""
f1 = figure(title='Strain rate control for reversal ...',
y_axis_type='log')
steps = np.unique(df['step'])
cmap = magma(np.size(steps))
# Fix things that are messed up first ...
if not malvern:
df = fix_strain_antonpaar(df, steps)
# Plot things, be careful with strain offsets
for no, s in enumerate(steps):
if strain_as_x:
xdata = np.abs(df[df['step'] == s]['strain'])
f1.xaxis.axis_label = '|gamma| (%)'
else:
xdata = df[df['step'] == s]['time']
f1.xaxis.axis_label = 't (s)'
rate = np.convolve(np.abs(df[df['step'] == s]['shearrate']),
np.ones(5) / 5,
mode='same')
est_rate = np.abs(np.mean(rate[-30:]))
f1.line(xdata, rate, line_color=cmap[no], line_width=1)
f1.line([0, np.max(xdata)], [est_rate, est_rate],
line_color=cmap[no],
line_dash='dashed')
show(f1)
return f1
def getdormcaseschart(transdata):
# # Area chart in plotly
from bokeh.palettes import magma
acol = magma(transdata.drop(['Date', 'tooltip'], axis=1).shape[1])[::-1]
chart2 = go.Figure()
# Area chart for each series
for i in reversed(range(transdata.shape[1] - 2)):
yname = transdata.drop(['Date', 'tooltip'], axis=1).columns[i]
y = transdata.drop(['Date', 'tooltip'], axis=1)[yname]
chart2.add_trace(
go.Scatter(
x=transdata['Date'],
y=y,
mode='lines',
line=dict(width=0.5, color='lightgray'),
fillcolor=acol[i],
stackgroup='one',
name=yname,
hovertemplate='%{y}',
))
chart2.update_layout(
title_text="Number of cases over time",
height=500,
width=1150,
template="plotly_white",
hovermode='x unified',
xaxis_showgrid=True,
yaxis_showgrid=True,
margin={'b': 0},
)
chart2.update_xaxes(tickangle=-45,
tickmode='linear',
ticks="outside",
showline=True,
rangemode="tozero")
chart2.update_yaxes(ticks="outside", showline=True, rangemode="tozero")
return chart2
def make_dataset(Movies):
Mov_split = Movies["Day"].str.split(' ', expand=True)
Movies["Month"] = Mov_split[0]
Movies["Date"] = Mov_split[1]
c_map = bp.magma(len(np.unique(Movies["Score"])))
c_dict = zip(np.unique(Movies["Score"]), c_map)
Col_MAP = dict(c_dict)
Movies["color"] = Movies["Score"].apply(lambda x: Col_MAP[x])
Movies["DateTime"] = pd.to_datetime(Movies["Release"],
format="%B %d, %Y")
Movies['alpha'] = np.where(Movies["Score"].astype(float) >= 90, 0.9,
0.25)
mov_dict = dict(Movie=Movies["Movie"],
Score=Movies["Score"],
Release=Movies["Release"],
alpha=Movies["alpha"],
color=Movies["color"])
return ColumnDataSource(mov_dict)
def box_plot(x,y,cl_ar,bok_file,epoch):
class_names = ['squat', 'deadlift', 'pushups', 'pullups', 'wallpushups', 'lunges', 'other', 'cleanandjerk']
num_of_classes = len(class_names)
df = pd.DataFrame(data={ 'tar': x, 'pred': y, 'class': cl_ar})
palette = magma(num_of_classes + 1)
p = figure(plot_width=600, plot_height=800, title=f"Ranking by exercise, epoch {epoch}")
p.xgrid.grid_line_color = None
p.xaxis.axis_label = 'Target ranking'
p.yaxis.axis_label = 'Predicted ranking'
for cl in range(num_of_classes):
if cl == 6:
continue
df2 = df.loc[df['class']==cl]
p.circle(x=jitter('tar', 0.5), y='pred', size=8, alpha=0.1, color=palette[cl], legend=class_names[cl], source=df2 )
p.line(x='tar', y='pred', line_width=2, alpha=0.5, color=palette[cl], source=df2.groupby(by="tar").mean())
p.legend.location = "top_left"
p.legend.click_policy="hide"
output_file(bok_file, title="Ranking by exercise")
save(p)
pil_image2 = get_screenshot_as_png(p)
neptune.send_image('rank_distances', pil_image2)
def corr_molecular(atm, filename_db, wavenumber, residual, max_plot,
threshold):
#get available data and grab needed cross sections
mols, pt_pairs = molecular_avail(filename_db)
Ts = []
Ps = []
for i in np.unique(atm.layer['pt_opa_index']):
Ps += [pt_pairs[i - 1][1]]
Ts += [pt_pairs[i - 1][2]]
#GET UNIQUE TEMPERATURES SO WE JUST HAVE ON PRESSURE FOR EACH TEMP
Ts_u, Ps_u = [], []
for i, j in zip(Ts, Ps):
if i not in Ts_u:
Ts_u += [i]
Ps_u += [j]
Ts = Ts_u
Ps = Ps_u
grab_m = get_molecular(filename_db, list(mols), Ts, Ps)
#rebin contimuum and compute correlations
cont = []
mol_t_pairs = []
counts = []
for i in mols:
for jt, jp in zip(Ts, Ps):
cx = grab_m[i][jt][jp]
x, cx_bi = mean_regrid(grab_m['wavenumber'], cx, newx=wavenumber)
grab_m[i][jt][jp] = cx_bi
mol_t_pairs += [(str(i), str(jt))]
pr = pearsonr(cx_bi, residual)[0]
if np.isnan(pr):
counts += [0]
else:
counts += [pr]
grab_m['wavenumber'] = x
#reformat the data to be in dictionary form so that we can tack in bokeh chart
#POSITIVE CORRELATIONS
data_p = {i[1]: [] for i in mol_t_pairs}
#NEGATIVE CORRELATIONS
data_n = {i[1]: [] for i in mol_t_pairs}
temp_strs = [str(i) for i in Ts]
i = 0
for ii in mols:
for jj in temp_strs:
if counts[i] >= 0:
data_p[jj] += [counts[i]]
data_n[jj] += [0]
else:
data_p[jj] += [0]
data_n[jj] += [counts[i]]
i += 1
data_p['molecules'] = mols
data_n['molecules'] = mols
#get molecules pairs with highest correlations for the negative (df_n) and
#the positive (df_c) correlations
df_n = pd.DataFrame(data_n, index=range(len(mols)))
cols = list(df_n.keys())
cols.pop(cols.index('molecules'))
df_n = df_n[(df_n[cols].T < -threshold).any()]
if df_n.shape[0] > 0:
mol_to_plot_n = df_n.sum(axis=1).sort_values(ascending=True)
mol_to_plot_n = mol_to_plot_n.loc[
mol_to_plot_n != 0].index.values[0:max_plot]
t_to_plot_n = {}
for i in mol_to_plot_n:
top_ts_n = df_n.loc[i, cols].sort_values().index.values[0]
t_to_plot_n[mols[i]] = top_ts_n
else:
t_to_plot_n = "none"
df_p = pd.DataFrame(data_p, index=range(len(mols)))
cols = list(df_p.keys())
cols.pop(cols.index('molecules'))
df_p = df_p[(df_p[cols].T > threshold).any()]
if df_p.shape[0] > 0:
mol_to_plot_p = df_p.sum(axis=1).sort_values(ascending=False)
mol_to_plot_p = mol_to_plot_p.loc[
mol_to_plot_p != 0].index.values[0:max_plot]
t_to_plot_p = {}
for i in mol_to_plot_p:
top_ts_p = df_p.loc[i, cols].sort_values(
ascending=False).index.values[0]
t_to_plot_p[mols[i]] = top_ts_p
else:
t_to_plot_p = "none"
#finally MAKE BIG ASS double PLOT
#first stack of correlations
color_mapper = LinearColorMapper(palette="Magma256",
low=min(Ts),
high=max(Ts))
p = figure(y_range=mols,
plot_height=300,
plot_width=600,
x_range=(-1 * len(temp_strs), len(temp_strs)),
title="Correlations with Molecules")
p.hbar_stack(temp_strs,
y='molecules',
height=0.9,
color=magma(len(temp_strs)),
source=ColumnDataSource(data_p))
p.hbar_stack(temp_strs,
y='molecules',
height=0.9,
color=magma(len(temp_strs)),
source=ColumnDataSource(data_n))
color_bar = ColorBar(color_mapper=color_mapper,
ticker=BasicTicker(),
label_standoff=12,
border_line_color=None,
location=(0, 0))
p.add_layout(color_bar, 'right')
#second take top correlated and plot it with the residuals
spec = figure(plot_height=300,
plot_width=650,
x_axis_type='log',
title="Residuals w/ Molecular Opacity",
y_range=[min(residual), max(residual)])
legend_it = []
spec.extra_y_ranges = {"cxs": Range1d()}
new_range = [0, -100]
spec.add_layout(LinearAxis(y_range_name="cxs"), 'right')
spec.line(1e4 / grab_m['wavenumber'],
residual,
color='black',
line_width=3)
icolor = 0
if t_to_plot_n != "none":
i = 0
for im in t_to_plot_n.keys():
ip = Ps[Ts.index(float(t_to_plot_n[im]))]
cx = grab_m[im][float(t_to_plot_n[im])][ip]
loc = np.where(cx != 0)
logcx = np.log10(cx[loc])
c = spec.line(1e4 / grab_m['wavenumber'][loc],
logcx,
color=Colorblind8[icolor],
y_range_name="cxs",
line_width=3)
new_range[0] = np.min([new_range[0], min(logcx)])
new_range[1] = np.max([new_range[1], max(logcx)])
legend_it.append((im + "_" + t_to_plot_n[im], [c]))
i += 1
icolor += 1
if t_to_plot_p != "none":
i = -1
for im in list(t_to_plot_p.keys()):
ip = Ps[Ts.index(float(t_to_plot_p[im]))]
cx = grab_m[im][float(t_to_plot_p[im])][ip]
loc = np.where(cx != 0)
logcx = np.log10(cx[loc])
c = spec.line(1e4 / grab_m['wavenumber'][loc],
logcx,
color=Colorblind8[icolor],
y_range_name="cxs",
line_width=3)
new_range[0] = np.min([new_range[0], min(logcx)])
new_range[1] = np.max([new_range[1], max(logcx)])
legend_it.append((im + "_" + t_to_plot_p[im], [c]))
i -= 1
icolor += 1
if ((t_to_plot_n != "none") | (t_to_plot_p != "none")):
legend = Legend(items=legend_it, location=(0, 0))
legend.click_policy = "mute"
spec.add_layout(legend, 'right')
spec.extra_y_ranges = {
"cxs": Range1d(start=new_range[0] * 1.1, end=new_range[1] * .9)
} #
p.y_range.range_padding = 0.1
p.ygrid.grid_line_color = None
p.axis.minor_tick_line_color = None
p.outline_line_color = None
return column(p, spec)
def calendar():
'''
# Calendar
'''
'''
$contents
'''
s = session('-v2')
output_file(filename='/dev/null')
'''
## Distance
Larger distances have larger symbols.
Place the cursor over the symbol for more information.
'''
df = Statistics(s). \
by_name(ActivityTopic, N.NAME). \
by_name(ActivityCalculator, N.ACTIVE_DISTANCE, N.ACTIVE_TIME, N.TOTAL_CLIMB).with_. \
copy({N.ACTIVE_DISTANCE: N.ACTIVE_DISTANCE_KM}).add_times().df
df['Duration'] = df[N.ACTIVE_TIME].map(format_seconds)
if present(df, N.TOTAL_CLIMB):
df.loc[df[N.TOTAL_CLIMB].isna(), [N.TOTAL_CLIMB]] = 0
calendar = Calendar(df, title=N.DISTANCE, not_hover=[N.ACTIVE_DISTANCE, N.ACTIVE_TIME])
calendar.std_distance()
'''
## Work Done and Fatigue
Larger increases in Fitness have larger symbols. Higher fatigue (relative to fitness) is redder.
Place the cursor over the symbol for more information.
'''
df = Statistics(s). \
by_name(ActivityTopic, N.NAME). \
by_name(ActivityCalculator, N.ACTIVE_DISTANCE, N.ACTIVE_TIME, N.TOTAL_CLIMB). \
by_name(ActivityCalculator, N._delta(N.FITNESS_ANY), like=True).df
df = Statistics(s). \
by_name(ResponseCalculator, N.ANY_FATIGUE_ANY, N.ANY_FITNESS_ANY, like=True). \
with_.drop_prefix(N.DEFAULT).into(df, tolerance='30m')
df['Duration'] = df[N.ACTIVE_TIME].map(format_seconds)
df.loc[df[N.TOTAL_CLIMB].isna(), N.TOTAL_CLIMB] = 0
work_done = sorted_numeric_labels(df.columns, N._delta(N.FITNESS))[0]
fitness = sorted_numeric_labels(df.columns, N.FITNESS)[0]
fatigue = sorted_numeric_labels(df.columns, N.FATIGUE)[0]
print(fatigue, fitness)
df['FF Ratio'] = df[fatigue] / df[fitness]
calendar = Calendar(df, title='Work Done and Fatigue',
not_hover=[N.ACTIVE_DISTANCE, N.ACTIVE_TIME] +
[column for column in df.columns if ':' in column])
calendar.background('square', fill_alpha=0, line_alpha=1, color='lightgrey')
calendar.set_palette('FF Ratio', K2R, lo=0.5, hi=2)
calendar.set_size(work_done, min=0.1, gamma=0.5)
calendar.foreground('square', fill_alpha=1, line_alpha=0)
calendar.show()
'''
## Distance, Climb and Direction
Larger distances have larger symbols. Higher climbs are redder.
The arc indicates the general direction relative to the start.
Place the cursor over the symbol for more information.
'''
df = Statistics(s). \
by_name(ActivityTopic, N.NAME). \
by_name(ActivityCalculator, N.ACTIVE_DISTANCE, N.ACTIVE_TIME, N.TOTAL_CLIMB, N.DIRECTION,
N.ASPECT_RATIO).df
df[N.DISTANCE_KM] = df[N.ACTIVE_DISTANCE]
df['Duration'] = df[N.ACTIVE_TIME].map(format_seconds)
if present(df, N.TOTAL_CLIMB):
df.loc[df[N.TOTAL_CLIMB].isna(), N.TOTAL_CLIMB] = 0
calendar = Calendar(df, title='Distance, Climb and Direction',
not_hover=[N.ACTIVE_DISTANCE, N.ACTIVE_TIME] +
[column for column in df.columns if ':' in column])
calendar.std_distance_climb_direction()
'''
## Distance, Work Done and Direction
Larger distances have larger symbols. Larger gains in fitness are redder.
The arc indicates the general direction relative to the start.
Place the cursor over the symbol for more information.
'''
df = Statistics(s). \
by_name(ActivityTopic, N.NAME). \
by_name(ActivityCalculator, N.ACTIVE_DISTANCE, N.ACTIVE_TIME, N.TOTAL_CLIMB, N.DIRECTION,
N.ASPECT_RATIO). \
by_name(ActivityCalculator, N._delta(N.FITNESS_ANY), like=True).df
df[N.DISTANCE_KM] = df[N.ACTIVE_DISTANCE]
df['Duration'] = df[N.ACTIVE_TIME].map(format_seconds)
df.loc[df[N.TOTAL_CLIMB].isna(), N.TOTAL_CLIMB] = 0
calendar = Calendar(df, title='Distance, Fitness and Direction',
not_hover=[N.ACTIVE_DISTANCE, N.ACTIVE_TIME] +
[column for column in df.columns if ':' in column])
calendar.std_distance_fitness_direction()
'''
## Fitness and Fatigue
Better fitness has larger symbols. When fatigue is higher symbols have "hotter" colours.
Place the cursor over the symbol for more information.
'''
df = Statistics(s). \
by_name(ActivityTopic, N.NAME). \
by_name(ActivityCalculator, N.ACTIVE_DISTANCE, N.ACTIVE_TIME). \
by_name(ActivityCalculator, N._delta(N.FITNESS_ANY), like=True).df
df = Statistics(s). \
by_name(ResponseCalculator, N.ANY_FATIGUE_ANY, N.ANY_FITNESS_ANY, like=True). \
with_.drop_prefix(N.DEFAULT).into(df, tolerance='30m')
fitness = sorted_numeric_labels(df.columns, N.FITNESS)[0]
fatigue = sorted_numeric_labels(df.columns, N.FATIGUE)[0]
df['FF Ratio'] = df[fatigue] / df[fitness]
calendar = Calendar(df, title='Fitness and Fatigue', scale=18, border_month=0, border_day=0)
calendar.set_size(fitness, min=0.1, gamma=0.5)
calendar.set_palette('FF Ratio', magma(256), lo=0.5, hi=2, min=0)
calendar.foreground('square', fill_alpha=1, line_alpha=0)
calendar.show()
'''
## Groups, Distance, Climb and Direction
Larger distances have larger symbols. Higher climbs are lighter.
The arc indicates the general direction relative to the start.
Pastel backgrounds group similar rides.
Place the cursor over the symbol for more information.
'''
dfa = Statistics(s). \
by_name(ActivityTopic, N.NAME). \
by_name(ActivityCalculator, N.ACTIVE_DISTANCE, N.ACTIVE_TIME, N.TOTAL_CLIMB, N.DIRECTION,
N.ASPECT_RATIO). \
by_name(ActivityCalculator, N._delta(N.FITNESS_ANY), like=True).df
dfa[N.DISTANCE_KM] = df[N.ACTIVE_DISTANCE]
dfa['Duration'] = df[N.ACTIVE_TIME].map(format_seconds)
dfa.loc[dfa[N.TOTAL_CLIMB].isna(), N.TOTAL_CLIMB] = 0
dfb = groups_by_time(s)
if present(dfb, N.GROUP):
dfb.loc[dfb[N.GROUP].isna(), N.GROUP] = -1
df = dfa.join(dfb)
calendar = Calendar(df, scale=15, border_day=0.1,
not_hover=[N.ACTIVE_DISTANCE, N.ACTIVE_TIME] +
[column for column in df.columns if ':' in column])
calendar.std_group_distance_climb_direction()
def make_plot(df, corp, color_palette):
palette_list = [
palettes.viridis(100),
palettes.inferno(100),
palettes.magma(100),
palettes.plasma(100),
]
colors = list(reversed(palette_list[color_palette]))
mapper = LinearColorMapper(palette=colors, low=0, high=100)
TOOLS = "hover,save,pan,box_zoom,reset,wheel_zoom"
TOOLTIPS = """
<div>
<div>
<span style="font-size: 20px; font-weight: bold;">score: @c%</span>
</div>
<div>
<span style="font-size: 16px; font-style: italic;">@a & @b</span>
</div>
</div>
"""
# tooltips=[('score','@c%'), ('doc_1', '@a'), ('doc_2', '@b')])
hm = figure(
x_range=corp,
y_range=list(reversed(corp)),
x_axis_location="above",
plot_width=900,
plot_height=900,
tools=TOOLS,
toolbar_location="below",
tooltips=TOOLTIPS,
)
hm.grid.grid_line_color = None
hm.axis.axis_line_color = None
hm.axis.major_tick_line_color = None
hm.axis.major_label_text_font_size = "8pt"
hm.axis.major_label_standoff = 0
hm.xaxis.major_label_orientation = pi / 3
hm.rect(
x="a",
y="b",
source=df,
width=1,
height=1,
line_color="#ffffff",
fill_color={
"field": "c",
"transform": mapper
},
)
color_bar = ColorBar(
color_mapper=mapper,
formatter=PrintfTickFormatter(format="%d%%"),
major_label_text_font_size="10pt",
label_standoff=10,
border_line_color=None,
location=(0, 0),
)
hm.add_layout(color_bar, "right")
js_resources = INLINE.render_js()
css_resources = INLINE.render_css()
script, div = components(hm)
return js_resources, css_resources, script, div
def render_mask(img_path, document_objs, document_name='Default_Document', output_path='./outputs/', save_html=False):
img = load_img(img_path)
bokeh.plotting.reset_output()
hover = HoverTool(
tooltips=[
("Name", "@name"),
("(x,y)", "($x, $y)"),
]
)
fig = figure(tools=[hover,
bokeh.models.WheelZoomTool(),
bokeh.models.PanTool()])
fig.hover.point_policy = "follow_mouse"
fig.sizing_mode='scale_width'
fig.image_url(url=[os.path.basename(img_path)], x=0, y=img.shape[0], w=img.shape[1], h=img.shape[0])
script = "active = cb_obj.active;"
labels = list(document_objs.keys())
color_map = bp.magma(len(labels))
args = dict()
total_objs = 0
for key_id, key in enumerate(labels):
xs = []
ys = []
for box in document_objs[key]:
_ = np.array(box).reshape(-1,2).T
xs.append(_[0])
ys.append(_[1])
ys=doccoor2planecoor(ys, img.shape[0])
data_source = dict(x=xs, y=ys,
name=["%s %d"%(key, idx) for idx in range(len(xs))])
falpha = 0.5*int('table' not in key.lower())
lcolor = 'blue' if 'table' in key.lower() else 'red'
lwidth = 3 if 'table' in key.lower() else 1
total_objs += len(document_objs[key])
args[key] = fig.patches('x', 'y', source=data_source, fill_color=color_map[key_id],
fill_alpha=falpha, line_color=lcolor, line_width=lwidth,
legend=key+': %d'%len(document_objs[key]))
r = args[key]
script += "\n%s.visible = active.includes(%d);"%(key, key_id)
fig.patch([],[], fill_color='red', fill_alpha=0, line_color='white', legend='Total region: %d'%total_objs)
fig.legend.click_policy="hide"
fig.legend.location = "top_left"
checkbox = CheckboxGroup(labels=labels, active=[])#active=[*range(len(labels))])
checkbox.callback = CustomJS(args=args, code=script)
plt_obj = [fig]
html = file_html(plt_obj, CDN, title=document_name)
if save_html:
base = os.path.join(output_path, document_name)
if os.path.exists(base):
shutil.rmtree(base)
os.makedirs(base)
shutil.copy(img_path, base)
with open(os.path.join(base, 'main.html'),'w') as g:
g.write(html)
return html
