def makeHoverCarpet(carpets, collabels, rowlabels, maxval, extralabels):
"""
makes a 3 carpet heatmap
"""
if (len(rowlabels) < 1):
print('no wells to show')
return
hv.extension('bokeh', width=90)
sprowlabels = [
rowlabels[i] + ',' + extralabels[i] for i in range(len(rowlabels))
]
heatmap1 = hv.HeatMap(
(collabels, sprowlabels, carpets[0])).opts(title=targets[0] + ' dRn')
heatmap2 = hv.HeatMap(
(collabels, sprowlabels, carpets[1])).opts(title=targets[1] + ' dRn')
heatmap3 = hv.HeatMap(
(collabels, sprowlabels, carpets[2])).opts(title=targets[2] + ' dRn')
tooltips = [('Well', '@y'), ('Cycle', '@x'), ('dRn', '@z')]
hover = HoverTool(tooltips=tooltips)
layout = heatmap1 + heatmap2 + heatmap3
layout.opts(
opts.HeatMap(tools=[hover],
cmap='jet',
colorbar=True,
invert_yaxis=True,
clim=(0.0, maxval),
width=400,
height=800,
xlabel='Cycle',
ylabel='Wells'))
return layout
def selected_points(index):
global data, ids
if len(ids) == 1 and index == []:
index = ids
if index and len(index) <= 1000:
for i in index:
for j in range(len(features)):
data.append(
(features[j], str(i), temp_feats[features[j]].iloc[i] *
models_feats_imp[choice2.value][j]))
b = temp_feats.iloc[index][features].mean()
c = temp_feats.iloc[0:len(loc_feats)][features].mean()
for j in range(len(features)):
data.append((features[j], 'Mean_value',
b[features[j]] * models_feats_imp[choice2.value][j]))
if ids == []:
ids = index
elif ids != index:
ids += index
else:
data = []
ids = []
return hv.HeatMap(data, kdims=['Points', 'Features'],
vdims=['Values']).options(colorbar=True,
width=950,
height=800,
tools=TOOLS,
xrotation=45).sort()
def correlation_heatmap(num_df, figsize=(800, 600)):
"""Correlation Heat Map
Parameters
----------
num_df : Numerical df
figsize : tuple
Ex. (width,height)
Returns
-------
Holoview Object
Return hv object that will be printed out
"""
num_corr = num_df.corr()
num_corr = pd.DataFrame(np.triu(num_corr),
index=num_corr.index,
columns=num_corr.columns)
num_corr = pd.melt(num_corr.reset_index(),
'index').rename(columns={
'index': 'x',
'variable': 'y'
})
plot = hv.HeatMap(num_corr, ['x', 'y'], 'value')
plot = plot.opts(
plot={
'width': figsize[0],
'height': figsize[1],
'xrotation': 90,
'tools': ['hover'],
'colorbar': True
})
return plot
def plot_commit_heatmap(commits,
width=900,
height=400,
resample=None,
xlabel=None,
title="Seriated heatmap",
cmap="viridis"):
xlabel = xlabel if xlabel is not None else commits.index.name
xlabel = "index" if xlabel is None else xlabel
commits = commits if resample is None else commits.resample(resample).sum()
commits.index = [x.strftime("%D") for x in commits.index]
mat = commits.values.T
mat = mat / mat.max(axis=1)[:, None]
heatmap = hv.HeatMap(
{
'x': commits.index,
'y': format_columns(commits.columns),
'z': mat.round(3) * 100
},
kdims=[('x', xlabel), ('y', 'Identity')],
vdims=('z', "% With respect to max"))
heatmap = heatmap.opts(cmap="viridis",
width=width,
height=width,
fontsize={'xticks': '2pt'},
tools=["hover"],
xrotation=90,
title=title)
return heatmap
def generar_heatmap(cluster, indice):
"""Genera el heatmap de accidentes de cada cluster"""
df_heat = (df_points_in_clusters.loc[df_points_in_clusters.cluster ==
cluster].groupby(
['dia_semana', 'hora'],
as_index=False).cluster.count())
df_heat = df_heat.pivot(index='dia_semana',
columns='hora',
values='cluster').fillna(0)
df_heat = df_heat.reindex(DIAS).reset_index()
df_heat = pd.melt(df_heat, id_vars='dia_semana')
df_heat = df_heat.assign(value=df_heat['value'].astype(int))
heatmap_opts = dict(width=600,
height=300,
cmap='viridis',
colorbar=True,
show_title=True,
tools=['hover'])
heatmap = hv.HeatMap(
df_heat,
kdims=['hora', 'dia_semana'],
vdims=['value'],
label=f'Incidentes por día y hora en el cluster: {indice}').options(
**heatmap_opts)
return heatmap
def cluster_viz(geocode, clusters):
data, group = get_cluster_data(geocode=geocode, clusters=clusters,
data_types=DATA_TYPES, cols=['casos'])
city_names = dict(get_city_names(group))
df_hm = data.reset_index().rename(columns={'index': 'week'})
df_hm = pd.melt(df_hm, id_vars=['week'], var_name='city', value_name='incidence')
df_hm['city'] = [int(re.sub('casos_', '', i)) for i in df_hm.city]
df_hm['city'] = [city_names[i] for i in df_hm.city]
# return df_hm
curve_opts = dict(line_width=10, line_alpha=0.4,tools=[])
overlay_opts = dict(width=900, height=200,tools=[])
hm_opts = dict(width=900, height=500, tools=[], logz=True, invert_yaxis=False, xrotation=90,
labelled=[], toolbar=None, xaxis=None)
heatmap = hv.HeatMap(df_hm)
heatmap.toolbar_location = None
graphs = [hv.Curve((data.index, data[i]), 'Time', 'Incidence') for i in data.columns]
final = graphs[0]
for i in graphs[1:]:
final = final * i
opts = {'HeatMap': {'plot': hm_opts}, 'Overlay': {'plot': overlay_opts},
'Curve': {'plot': curve_opts,
'style': dict(color='blue', line_alpha=0.2)}}
return (heatmap + final).opts(opts).cols(1)
def _heatmap_holoviews(heatmap_data, x, y, z):
if hv is None:
raise ImportError(
"holoviews module could not be imported. use a different engine")
heatmap = hv.HeatMap(heatmap_data.reset_index(), [f'{x}_bin', f'{y}_bin'],
z)
return heatmap
def dictionary_pair_overlap(alpha, beta):
overlap_dim = hv.Dimension("Overlap Count", value_format=lambda x: f"{x}")
data = [(f"{ak}: {len(av)}", f"{bk}: {len(bv)}", len(set.intersection(set(av), set(bv))))
for (ak, av), (bk, bv) in itertools.product(alpha.items(), beta.items())]
heatmap = hv.HeatMap(data, vdims=overlap_dim).opts(labelled=[], colorbar=True)
return heatmap * hv.Labels(heatmap)
def grid_plot_experiments(comet_api: comet_ml.API, experiments: APIExperiments, p1_name: str, p2_name: str,
metrics: List[str] = ['train_acc', 'dev_acc', 'test_acc'], parameters: List[str] = [],
fig_size: int = 220) -> hv.core.layout.Layout:
targets_data = _download_data(comet_api, experiments, p1_name, p2_name, metrics, parameters)
layout = hv.Layout()
for k, v in targets_data.items():
layout += hv.HeatMap(v, kdims=[p1_name, p2_name], vdims=k).sort().opts(title=k, cmap='greens').redim.range(z=(0, None))
return layout.opts(fig_size=fig_size, framewise=True)
def display(self,
data: Union[TrackQC, pd.DataFrame],
tracks: List[str] = None,
beads: List[int] = None) -> pd.DataFrame:
"Outputs heatmap with the status of the beads per track"
return hv.HeatMap(self.dataframe(data, tracks, beads),
kdims=['bead', 'track'],
vdims=['errorid', 'mostcommonerror',
'modification']).options(**self.styleopts)
def gpu_map(data):
data_algo1 = [d.split(",") for d in data['algo-1']]
data_algo2 = [d.split(",") for d in data['algo-2']]
data_algo1 = clean(data_algo1)
data_algo2 = clean(data_algo2)
algo1_map = hv.HeatMap(data_algo1).options(cmap='coolwarm',
title="GPU Heatmap (algo1)",
width=400,
colorbar=True).sort()
algo2_map = hv.HeatMap(data_algo2).options(cmap='coolwarm',
title="GPU Heatmap (algo2)",
width=400,
colorbar=True).sort()
full_plot = algo1_map + algo2_map.opts(shared_axes=False)
return full_plot
def model_weights(model):
"""
Takes a model and returns the weights as a grid
of heatmaps using Holoviews.
"""
# get the weights out of the model
weights = model.get_weights_topo()
# make heatmaps using holoviews
heatmaps = None
for w in weights:
w = {(i, j): w[i, j][0]
for i in range(w.shape[0]) for j in range(w.shape[1])}
if heatmaps == None:
heatmaps = hl.HeatMap(w)
else:
heatmaps += hl.HeatMap(w)
return heatmaps
def plot_cov(self, **kwargs):
data = [(f"{li}: {self.data.x[i]}", f"{lj}: {self.data.x[j]}",
self.cov[i, j])
for i, li in zip(range(len(self.data)), self.labels)
for j, lj in zip(range(len(self.data)), self.labels)]
return hv.HeatMap(data).opts(tools=["hover"],
width=800,
height=800,
invert_yaxis=True,
xrotation=90)
def empty_heatmap():
"""Crea un heatmap con datos nulos"""
heatmap_opts = dict(width=600,
height=300,
cmap='viridis',
colorbar=True,
show_title=False,
tools=['hover'])
heatmap = hv.HeatMap(df_empty,
kdims=['hora', 'dia_semana'],
vdims=['value']).options(**heatmap_opts)
return heatmap
def create_figure(self):
data = self.solve()
heatmap = hv.HeatMap(data,
label='Optimal Ads Served',
kdims=['hour', 'Advertisement id'],
vdims=['count'])
heatmap.opts(
tools=['hover'],
colorbar=True,
toolbar=None,
invert_yaxis=True,
width=self.width - self.panel_width,
)
return renderer.get_plot(heatmap).state
def plot_adjacency_matrix(G,
save=False,
filename=None,
weight="weighted_score",
log=False,
width=200,
height=200,
fontsize=10,
fontscale=1.5):
"""Flattens and plots an adjecency matric for a given graph.
If a split graph is provided, plots adjacency matrix for each interaction.
Weight can be "weighted_score" or "score".
Returns: Holoviews heatmap
"""
import numpy as np
import holoviews as hv
from holoviews import opts
import networkx as nx
hv.extension('bokeh')
# Create adjecency matrix and sort index and columns by name
matrix = nx.to_pandas_adjacency(G, weight=weight)
if log:
matrix = np.log10(matrix)
matrix = matrix.sort_index(ascending=True)
matrix = matrix[matrix.index.values]
matrix = matrix.stack()
matrix = matrix.reset_index(name="values")
matrix.columns = ["source", "target", "values"]
# Plot the matrix as a heatmap
heatmap = hv.HeatMap(matrix, kdims=["target", "source"])
# Rotate X lables and show the color bar
heatmap.opts(
opts.HeatMap(tools=["hover"],
xrotation=90,
colorbar=True,
width=width,
height=height,
fontsize=fontsize,
fontscale=fontscale))
if save is True:
hv.save(heatmap, filename)
return heatmap
def get_heatmap(data,
lim,
title,
kdim='x',
vdim='Iteration',
height=200):
return hv.HeatMap(data, kdims=[kdim, vdim]).opts(
opts.HeatMap(tools=['hover'],
colorbar=True,
width=350,
height=height,
invert_yaxis=True,
ylabel='Iteration',
title=title,
clim=(-lim, lim),
cmap='RdBu'))
def heat_hv(df, id_prop="Compound_Id", cmap="bwr", invert_y=False):
if not HOLOVIEWS:
raise ImportError("# holoviews library could not be imported")
df_parm = df[[id_prop] + ACT_PROF_PARAMETERS].copy()
df_len = len(df_parm)
col_bar = False if df_len < 3 else True
values = list(df_parm.drop(id_prop, axis=1).values.flatten())
max_val = max(values)
min_val = min(values)
max_val = max(abs(min_val), max_val)
hm_opts = dict(width=950, height=40 + 30 * df_len, tools=['hover'], invert_yaxis=invert_y,
xrotation=90, labelled=[], toolbar='above', colorbar=col_bar, xaxis=None,
colorbar_opts={"width": 10})
hm_style = {"cmap": cmap}
opts = {'HeatMap': {'plot': hm_opts, "style": hm_style}}
df_heat = cpt.melt(df_parm, id_prop=id_prop)
heatmap = hv.HeatMap(df_heat).redim.range(Value=(-max_val, max_val))
return heatmap(opts)
def genesetcollection_overlap_heatmap(alpha: dict, beta: dict):
"""
View the overlap (as a heatmap) of two GeneSetCollection dictionaries,
as provided by gsc.as_dict().
:param alpha:
:param beta:
:return:
"""
overlap_dim = hv.Dimension("Overlap Count", value_format=lambda x: f"{x}")
data = [(f"{ak}: {len(av)}", f"{bk}: {len(bv)}",
len(set.intersection(set(av), set(bv))))
for (ak,
av), (bk,
bv) in itertools.product(alpha.items(), beta.items())]
heatmap = hv.HeatMap(data, vdims=overlap_dim)
return heatmap * hv.Labels(heatmap)
def showidentifiedpeaks(
data, # pylint: disable=too-many-arguments
missingvalue=20,
dynmap=False,
adjoint=True,
width=600,
height=100):
"""
Show expected peaks in a heatmap
"""
# pylint: disable=too-many-locals
if dynmap:
fcn = lambda x: showidentifiedpeaks(data.loc[[x]], missingvalue, None,
False)
return (hv.DynamicMap(fcn, kdims=[
'track'
]).redim.values(track=sorted(data.index.levels[0].unique())))
vals = (data.reset_index(level=[0, 2]).loc[list(
data.groupby(level=1).hfsigma.mean().sort_values().index)].sort_values(
['reference']).assign(dist=lambda x: np.abs(x.delta)))
if len(vals.track.unique()) > 1:
ref = 'ref'
vals['ref'] = vals.reference.astype(str) + " " + vals.track
else:
ref = 'reference'
inds = vals.delta.isna().sum(level=0).sort_values().index
vals = pd.concat([vals.loc[[i]] for i in inds])
opts = dict(xrotation=90, width=width)
hmap = hv.HeatMap(vals.fillna(missingvalue), [ref, "bead"], "dist")
if not adjoint:
opts.pop('width')
return hmap.options(**opts)
beads = (hv.Bars(vals.delta.isna().sum(level=0)[::-1]).redim(
x="bead", y="missbeads"))
pos = (hv.Bars(vals.reset_index().set_index(ref).delta.isna().sum(
level=0)).redim(x=ref, y="misspos"))
return (hmap.options(**opts) << beads.options(width=height, yaxis=None) <<
pos.options(height=height, width=width, xaxis=None))
def get_ccaa_heatmap(complete_df):
df = complete_df[['Comunidad Autónoma', 'Fecha', 'Casos']]
df = df.sort_values(by=['Comunidad Autónoma', 'Fecha'],
ascending=[False, True])
df.Fecha = df.loc[:, 'Fecha'].dt.strftime('%d-%m')
heatmap = hv.HeatMap(df,
kdims=['Fecha', 'Comunidad Autónoma'],
vdims='Casos')
heatmap.opts(width=width,
height=450,
tools=['hover'],
logz=True,
title='Casos acumulados',
toolbar='above',
xlabel='Fecha',
ylabel='',
colorbar=True,
clim=(1, np.nan),
xrotation=90)
return heatmap
def makeHoverHeatMap(df, labelcol, hovercols, vmin=25, vmax=45):
"""
this makes a holoviews heatmap from the dataframe
x and y and z (column and row and Ct) columns should be the first two columns
labelcol values are shown on the heatmap
hovercols values will be shown on hover
"""
hv.extension('bokeh', width=90)
heatmap = hv.HeatMap(df)
#tooltips=[('Row','@Row'),('Col','@Column'),('JCT','@JCT'),('CT','@CT'),('JCategory','@JCategory'),('Category','@Category'),('Sample','@Sample')]
tooltips = [(hovercols[i], '@' + hovercols[i])
for i in range(len(hovercols))]
hover = HoverTool(tooltips=tooltips)
heatmap.opts(tools=[hover],
colorbar=True,
invert_yaxis=True,
width=1500,
height=800,
clim=(vmin, vmax),
xlim=(0.5, 24.5))
return heatmap * hv.Labels(heatmap, vdims=[labelcol])
def _plot_cpu_heatmap(self, event, bins, xbins, cmap):
"""
Plot some data in a heatmap-style 2d histogram
"""
df = self.trace.df_event(event)
df = df_window(df, window=self.trace.window, method='exclusive', clip_window=False)
x = df.index
y = df['target_cpu']
if xbins:
warnings.warn('"xbins" parameter is deprecated and will be removed, use "bins" instead', DeprecationWarning)
bins = xbins
nr_cpus = self.trace.cpus_count
hist = np.histogram2d(y, x, bins=[nr_cpus, bins])
z, _, x = hist
y = list(range(nr_cpus))
return hv.HeatMap(
(x, y, z),
kdims=[
# Manually set dimension name/label so that shared_axes works
# properly.
# Also makes hover tooltip better.
hv.Dimension('Time'),
hv.Dimension('CPU'),
],
vdims=[
hv.Dimension(event),
]
).options(
colorbar=True,
xlabel='Time (s)',
ylabel='CPU',
# Viridis works both on bokeh and matplotlib
cmap=cmap or 'Viridis',
yticks=[
(cpu, f'CPU{cpu}')
for cpu in y
]
)
def generate_single_plot(comet_api,
SOPT,
STR="r",
COPT="sgd",
E=1,
project="emnist-s"):
clr = "Client Learning Rate (log10)"
slr = "Server Learning Rate (log10)"
exps = get_experiments(comet_api, SOPT, STR, COPT, E, project)
slrv = exp_params2list(exps, "SERVER_LEARNING_RATE", float)
clrv = exp_params2list(exps, "CLIENT_LEARNING_RATE", float)
acc = exp_metrics2list(exps, "last_avg_acc", float)
df = pd.DataFrame({
slr: np.log10(slrv),
clr: np.log10(clrv),
"Accuracy": acc
})
i = df["Accuracy"].idxmax()
m = df.iloc[i]
return (
hv.HeatMap(df, kdims=[clr, slr]).opts(colorbar=True, cmap="viridis") *
hv.Ellipse(m[clr], m[slr], 0.5)).opts(fig_inches=10)
def display(self,
trackqc: TrackQC,
tracks: List[str] = None,
normalize=True) -> hv.Layout:
"""
Outputs a heatmap. Columns are types of Error and rows are tracks. Each
cell presents the percentage of appearance of the specific error at the
specific track.
"""
disc = self.dataframe(trackqc, tracks, normalize)
value = self.value(normalize)
nbeads = len(trackqc.status.index)
hmap = (hv.HeatMap(disc[~disc['error'].isna()],
kdims=['error', 'track'],
vdims=[value, 'beads']).redim.range(**{
value: (-100, 100) if normalize else (-nbeads,
nbeads)
}).redim.label(error=" ").options(**self.styleopts))
fmt = (lambda x: f'{abs(x):.01f}') if normalize else (
lambda x: f'{abs(x):.1f}')
return ((hmap *
hv.Labels(hmap).redim.value_format(**{value: fmt})).clone(
label=self.title))
def geneset_overlap_heatmap(lineament_collection, keys=None, mode="overlap"):
lineament_dict = lineament_collection.as_dict(keys)
if mode == "overlap":
overlap_dim = hv.Dimension("Overlap Count", value_format=lambda x: f"{x}")
data = [(ak, bk, len(set.intersection(set(av), set(bv))))
for (ak, av), (bk, bv) in itertools.permutations(lineament_dict.items(), 2)
if ak != bk]
elif mode == "percent":
overlap_dim = hv.Dimension("Overlap Percent", value_format=lambda x: f"{x:.0%}")
zero_filtered_dict = {k: v for k, v in lineament_dict.items()
if len(v) > 0}
data = [(ak, bk, len(set.intersection(set(av), set(bv))) / len(set(av)))
for (ak, av), (bk, bv) in itertools.permutations(zero_filtered_dict.items(), 2)
if ak != bk]
else:
raise ValueError(f"{mode} is not a valid mode. Select from 'overlap' or 'percent'.)")
heatmap = hv.HeatMap(data, vdims=overlap_dim) # .options(xrotation=45, width=450, height=450, labelled=[],
# colorbar=True)
return heatmap * hv.Labels(heatmap)
def _get_bokeh_chart(self,
x_field,
y_field,
chart_type,
label,
opts,
style,
options={},
**kwargs):
"""
Get a Bokeh chart object
"""
if isinstance(x_field, list):
kdims = x_field
else:
kdims = [x_field]
if isinstance(y_field, list):
vdims = y_field
else:
vdims = [y_field]
args = kwargs
args["data"] = self.df
args["kdims"] = kdims
args["vdims"] = vdims
if label is not None:
args["label"] = label
else:
if self.label is not None:
args["label"] = self.label
chart = None
try:
if chart_type == "line":
chart = hv.Curve(**args)
if chart_type == "hline":
chart = self._hline_bokeh_(y_field)
elif chart_type == "point":
chart = hv.Scatter(**args)
elif chart_type == "area":
chart = hv.Area(**args)
elif chart_type == "bar":
chart = hv.Bars(**args)
elif chart_type == "hist":
chart = hv.Histogram(**args)
elif chart_type == "errorBar":
chart = hv.ErrorBars(**args)
elif chart_type == "heatmap":
chart = hv.HeatMap(**args)
elif chart_type == "lreg":
chart = self._lreg_bokeh(**args)
elif chart_type == "sline":
window_size, y_label = options["window_size"],
options["y_label"]
chart = self._sline_bokeh(window_size, y_label)
if chart is None:
self.err("Chart type " + chart_type + " unknown",
self._get_bokeh_chart)
return
endchart = chart(plot=opts, style=style)
return endchart
except DataError as e:
msg = "Column not found in " + x_field + " and " + y_field
self.err(e, self._get_bokeh_chart, msg)
except Exception as e:
self.err(e)
def plot_confussion_matrix(
y_test,
y_pred,
target_names: list = None,
cmap: str = "YlGnBu",
width=500,
height: int = 400,
title: str = "Confusion matrix",
normalize: bool = False,
):
value_label = "examples"
target_label = "true_label"
pred_label = "predicted_label"
label_color = "color"
def melt_distances_to_heatmap(distances: pd.DataFrame) -> pd.DataFrame:
dist_melt = pd.melt(distances.reset_index(),
value_name=value_label,
id_vars="index")
dist_melt = dist_melt.rename(columns={
"index": target_label,
"variable": pred_label
})
dist_melt[target_label] = pd.Categorical(dist_melt[target_label])
dist_melt[pred_label] = pd.Categorical(dist_melt[pred_label])
coords = dist_melt.copy()
coords[target_label] = dist_melt[target_label].values.codes
coords[pred_label] = dist_melt[pred_label].values.codes
return coords[[pred_label, target_label, value_label]]
conf_matrix = confusion_matrix(y_test, y_pred)
if normalize:
conf_matrix = np.round(
conf_matrix.astype("float") /
conf_matrix.sum(axis=1)[:, np.newaxis], 3)
# Adjust label color to make them readable when displayed on top of any colormap
df = melt_distances_to_heatmap(pd.DataFrame(conf_matrix))
mean = df[value_label].mean()
df[label_color] = -df[value_label].apply(lambda x: int(x > mean))
if target_names is not None:
df[target_label] = df[target_label].apply(lambda x: target_names[x])
df[pred_label] = df[pred_label].apply(lambda x: target_names[x])
true_label_name = "Actual label"
pred_label_name = "Predicted label"
tooltip = [
(true_label_name, "@{%s}" % target_label),
(pred_label_name, "@{%s}" % pred_label),
("Examples", "@{%s}" % value_label),
]
hover = HoverTool(tooltips=tooltip)
heatmap = hv.HeatMap(df, kdims=[pred_label, target_label])
heatmap.opts(title=title,
colorbar=True,
cmap=cmap,
width=width,
height=height,
tools=[hover])
labeled = heatmap * hv.Labels(heatmap).opts(text_color=label_color,
cmap=cmap)
return labeled.options(xlabel=pred_label_name,
ylabel=true_label_name,
invert_yaxis=True)
def plot_infection_rates_by_contact_models(
df_or_time_series: Union[pd.DataFrame, dd.core.DataFrame],
show_reported_cases: bool = False,
unit: str = "share",
fig_kwargs: Optional[Dict[str, Any]] = None,
) -> hv.HeatMap:
"""Plot infection rates by contact models.
Parameters
----------
df_or_time_series : Union[pandas.DataFrame, dask.dataframe.core.DataFrame]
The input can be one of the following two.
1. It is a :class:`dask.dataframe.core.DataFrame` which holds the time series
from a simulation.
2. It can be a :class:`pandas.DataFrame` which is created with
:func:`prepare_data_for_infection_rates_by_contact_models`. It allows to
compute the data for various simulations with different seeds and use the
average over all seeds.
show_reported_cases : bool, optional
A boolean to select between reported or real cases of infections. Reported cases
are identified via testing mechanisms.
unit : str
The arguments specifies the unit shown in the figure.
- ``"share"`` means that daily units represent the share of infection caused
by a contact model among all infections on the same day.
- ``"population_share"`` means that daily units represent the share of
infection caused by a contact model among all people on the same day.
- ``"incidence"`` means that the daily units represent incidence levels per
100,000 individuals.
fig_kwargs : Optional[Dict[str, Any]], optional
Additional keyword arguments which are passed to ``heatmap.opts`` to style the
plot. The keyword arguments overwrite or extend the default arguments.
Returns
-------
heatmap : hv.HeatMap
The heatmap object.
"""
fig_kwargs = (DEFAULT_IR_PER_CM_KWARGS if fig_kwargs is None else {
**DEFAULT_IR_PER_CM_KWARGS,
**fig_kwargs
})
if _is_data_prepared_for_heatmap(df_or_time_series):
df = df_or_time_series
else:
df = prepare_data_for_infection_rates_by_contact_models(
df_or_time_series, show_reported_cases, unit)
hv.extension("bokeh", logo=False)
heatmap = hv.HeatMap(df)
plot = heatmap.opts(**fig_kwargs)
return plot
def plot_connectivity_matrix(connectivity_matrix,
atlas_labels,
threshold=None,
dst_dir=None,
filename=None):
'''Plot a connectivity matrix. This function is very similar to nilearn.plotting.plot_matrix
but uses the bokeh backend and is therefore interactive
Parameters
----------
connectivity_matrix : np.array
A symmetric connectivity matrix.
atlas_labels : pd.Series or list
A list-like object providing names of each atlas region.
threshold : float or int, optional
Apply a threshold to the connectivity matrix before plotting. Values
lower than this threshold will be set to 0.
dst_dir : str, optional
Name of the output directory. The default is None.
filename : str, optional
Name of the file (must be provided including the extenstion).
The default is None.
Returns
-------
connectogram_plot : holoviews.element.raster.HeatMap
The the connectivity matrix plot object.
'''
# copy matrix
connectivity_matrix = connectivity_matrix.copy()
# convert to pd.DataFrame for further processing
connectivity_matrix_df = pd.DataFrame(data=connectivity_matrix,
columns=atlas_labels,
index=atlas_labels)
# Ensure that index name has the default name 'Index'
if connectivity_matrix_df.index.name:
connectivity_matrix_df.index.name = None
# stack connectivity_matrix
connectivity_matrix_stacked = connectivity_matrix_df.stack().reset_index()
connectivity_matrix_stacked.columns = ['source', 'target', 'value']
if threshold:
connectivity_matrix_stacked['value'].where(
connectivity_matrix_stacked['value'] >= threshold, 0, inplace=True)
connectivity_matrix_stacked_ds = hv.Dataset(connectivity_matrix_stacked,
['source', 'target'])
heatmap = hv.HeatMap(connectivity_matrix_stacked_ds)
heatmap.opts(
opts.HeatMap(tools=['hover'],
colorbar=True,
xaxis='bare',
yaxis='bare',
cmap='blues_r'))
# save plot
if dst_dir:
if not filename:
raise ValueError('Please provide a filename')
dst_path = dst_dir + filename
hv.save(heatmap, dst_path)
# FIXME: this doesn't work for me in Spyder
show(hv.render(heatmap))
return heatmap
