def show_histogram(
data, ax: plt.Axes, start: float, end: float, group_inds=None, nbins: int = 30
):
if not len(data):
return
if group_inds is None:
height, x = np.histogram(np.hstack(data), bins=nbins, range=(start, end))
width = np.diff(x[:2])
height = height / len(data) / width
plt.bar(x[:-1], height, edgecolor=(0.3, 0.3, 0.3), width=width, align="edge")
else:
data = np.asarray(data, dtype="object")
# group_inds = np.asarray(group_inds)
for group in np.unique(group_inds):
this_data = np.hstack(data[group_inds == group])
height, x = np.histogram(this_data, bins=nbins, range=(start, end))
width = np.diff(x[:2])
height = height / np.sum(group_inds == group) / width
ax.bar(
x[:-1],
height,
color=color_wheel[group % len(color_wheel)],
edgecolor=(0.3, 0.3, 0.3),
width=width,
align="edge",
alpha=0.6,
)
def generate_gsr_max_min_plot(axes: plt.Axes, stimulus_data: pd.DataFrame):
"""
My plot
"""
plt.sca(axes)
windowed_data_max = stimulus_data.resample("2min").max()[:15]
windowed_data_min = stimulus_data.resample("2min").min()[:15]
time = convert_date_to_time(windowed_data_max.index)
axes.set_title(
"Range-Corrected GSR Maximums and Minimums Over Two-Minute Windows")
axes.set_xlabel("Time (minutes)", fontsize="large")
axes.set_ylabel("Range-Corrected GSR (dimensionless)")
axes.set_ylim(0, 1)
set_windowed_x_axis(axes)
axes.bar(time,
windowed_data_max[RANGE_CORRECT_EDA],
width=2,
align="edge",
edgecolor="black")
axes.bar(time,
windowed_data_min[RANGE_CORRECT_EDA],
width=2,
align="edge",
edgecolor="black")
def multiple_bar_chart(ax: plt.Axes,
xvalues: list,
yvalues: dict,
title: str,
xlabel: str,
ylabel: str,
percentage=False):
ax.set_title(title)
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
x = np.arange(len(xvalues)) # the label locations
ax.set_xticks(x)
ax.set_xticklabels(xvalues, fontsize='small')
if percentage:
ax.set_ylim(0.0, 1.0)
width = 0.8 # the width of the bars
step = width / len(yvalues)
i = 0
for name, y in yvalues.items():
ax.bar(x + i * step, y, step, label=name)
i += 1
ax.legend(loc='lower center',
ncol=len(yvalues),
bbox_to_anchor=(0.5, -0.2),
fancybox=True,
shadow=True)
def generate_gsr_range_correct_means_plot_two_min(axes: plt.Axes,
stimulus_data: pd.DataFrame):
"""
Plots range corrected means over two minute windows.
:param axes: the axes to plot on
:param stimulus_data: the raw stimulus data
:return: None
"""
plt.sca(axes)
windowed_data = stimulus_data.resample("2min").mean()[:15]
time = convert_date_to_time(windowed_data.index)
axes.set_title(
"Range-Corrected GSR Means Over Two-Minute Windows (Range Correct on Two-Min)"
)
axes.set_xlabel("Time (minutes)", fontsize="large")
axes.set_ylabel("Range-Corrected GSR (dimensionless)")
axes.set_ylim(0, 1)
set_windowed_x_axis(axes)
axes.bar(time,
windowed_data["gsr_two_min"],
width=2,
align="edge",
edgecolor="black",
color="orange")
def multiple_bar_chart(xvalues: list,
yvalues: dict,
ax: plt.Axes = None,
title: str = '',
xlabel: str = '',
ylabel: str = '',
percentage=False):
ax = set_axes(xvalues,
ax=ax,
title=title,
xlabel=xlabel,
ylabel=ylabel,
percentage=percentage)
x = np.arange(len(xvalues)) # the label locations
width = 0.8 / (len(xvalues) * len(yvalues))
# the width of the bars
step = width / len(xvalues)
i: int = 0
for metric in yvalues:
ax.bar(x + i * width,
yvalues[metric],
width=width,
align='center',
label=metric)
i += 1
ax.set_xticks(x + width / len(xvalues) - step / 2)
ax.legend(fontsize='x-small', title_fontsize='small')
def npsPlot(pkg: NotePkg, ax:plt.Axes = None, window=1000, stride=None, legend=True, tickStepSize=60000,
barKwargs=None) -> plt.Axes:
""" This creates an NPS Plot with the axes.
:param pkg: Any Note Package
:param ax: The axis to plot on, if None, we use gca()
:param window: The window of the roll
:param stride: The stride length of the roll
:param legend: Whether to show the legend
:param tickStepSize: How many milliseconds per tick
:param barKwargs: The kwargs to pass into plot()
"""
if ax is None: ax = plt.gca()
if barKwargs is None: barKwargs = {}
dns = pkg.rollingDensity(window=window, stride=stride)
prevHeights = None
for lisType, lis in dns.items():
if all(v == 0 for v in lis.values()): continue
currIndexes = list(lis.keys())
currHeights = [RAConst.secToMSec(v / window) for v in list(lis.values())]
ax.bar(currIndexes, currHeights,
width=pkg.duration() / (len(lis.keys()) - 1), # -1 to make sure there's no gaps
bottom=prevHeights, # Aligns next bar heights with previous
label=lisType,
**barKwargs) # Aligns the bars next to each other
prevHeights = currHeights
if legend: ax.legend()
ax.set_xlim(left=pkg.firstOffset(), right=pkg.lastOffset())
ax = timedXAxis(ax=ax, stepSize=tickStepSize)
return ax
def weight_per_neuron(ax: plt.Axes, w: np.ndarray, neurons: np.ndarray):
width = 0.7
num = w.shape[0]
w_n, w_n_a, x_n_a = [], [], []
x_n = np.arange(1, num + 1)
for i in range(num):
w_n.append(np.sum(w[i]))
if neurons[i] == 1:
sm = 0
for j in range(num):
sm += w[i][j] if neurons[j] == 1 else 0
w_n_a.append(sm)
x_n_a.append(x_n[i])
w_max = np.max(w_n)
# customize layout
step = (num // 10)
steps = x_n[0::max(1, step)]
steps = np.array(steps) - 1
steps[0] = 1
if steps[-1] != x_n[-1]:
steps = np.append(steps, x_n[-1])
major_locator_n = tik.FixedLocator(steps)
major_locator_n.view_limits(1, num)
minor_locator_n = tik.MultipleLocator(1)
ax.xaxis.set_major_locator(major_locator_n)
ax.xaxis.set_minor_locator(minor_locator_n)
ax.set_xlim(0, num + 1)
ax.set_ylim(0, max(2, w_max))
# colormap for active neurons:
y = np.array(w_n_a) - 1
sp = cm.get_cmap("spring").reversed()
atu = cm.get_cmap("autumn").reversed()
colors = [
atu(abs(y_i) / 1) if y_i < 0 else sp(y_i / max(1, w_max - 1))
for y_i in y
]
# red dash line:
ax.plot((0, num + 1), (1, 1), 'red', linestyle='--')
# gray bars for inactive neurons
ax.bar(x_n, w_n, width, color='gray')
# colored active neurons
ax.bar(x_n_a, w_n_a, width, color=colors)
def plot_4B(ax: plt.Axes):
df = pd.DataFrame(L).transpose()
res = GroupBMC(df.to_numpy()).get_result()
ax.bar(np.arange(4),
res.protected_exceedance_probability,
color='white',
edgecolor='k')
ax.set_ylim(0, 1)
ax.set_ylabel('PXP')
ax.set_xticks(np.arange(4))
ax.set_xticklabels([Model.name for Model in Models], rotation=22.5)
def bar_chart(ax: plt.Axes,
xvalues: list,
yvalues: list,
title: str,
xlabel: str,
ylabel: str,
percentage=False):
ax.set_title(title)
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
ax.set_xticklabels(xvalues, rotation=90, fontsize='small')
if percentage:
ax.set_ylim(0.0, 1.0)
ax.bar(xvalues, yvalues, edgecolor='grey')
def bar_chart(xvalues: list,
yvalues: list,
ax: plt.Axes = None,
title: str = '',
xlabel: str = '',
ylabel: str = '',
percentage=False):
ax = set_axes(xvalues,
ax=ax,
title=title,
xlabel=xlabel,
ylabel=ylabel,
percentage=percentage)
ax.bar(xvalues, yvalues, edgecolor=cfg.LINE_COLOR, color=cfg.FILL_COLOR)
def bar_chart(ax: plt.Axes,
xvalues: list,
yvalues: list,
title: str,
xlabel: str,
ylabel: str,
percentage=False,
logScale=False):
ax.set_title(title)
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
if logScale:
ax.set_yscale('log')
ax.set_xscale('log')
if percentage:
ax.set_ylim(0.0, 1.0)
ax.bar(xvalues, yvalues, edgecolor='grey')
def plot_daily_hours_over_timespan(axes: plt.Axes,
projects_dict: dict,
start_datetime=datetime.datetime.now(),
end_datetime=datetime.datetime.now(),
) -> plt.Axes:
# ~ Populating the plot
dts = [(start_datetime + datetime.timedelta(days=offset))
for offset in range((end_datetime - start_datetime).days + 1)]
for index, dt in enumerate(dts, start=1):
date_string = dt.strftime(settings.HARVEST_DATETIME_FORMAT)
previous_hours = 0
for project_id, project_data in projects_dict.items():
if date_string in project_data['daily_hours']:
hours = project_data['daily_hours'][date_string]
axes.bar(x=index,
bottom=previous_hours,
height=hours,
color=project_data['color'])
previous_hours += hours
axes.text(x=index,
y=previous_hours + 0.1,
s=f'{previous_hours:0.2f}',
fontsize='large',
ha='center')
# ~ Additional plot info
yticks = list(range(1, len(dts) + 1))
axes.set_xlim(yticks[0] - 0.5, yticks[-1] + 0.5)
axes.set_xticks(yticks)
axes.set_xticklabels([dt.strftime('%d.%m.%Y\n(%A)') for dt in dts])
axes.set_ylim(0, 12)
axes.set_title('Daily hours')
custom_lines = []
custom_labels = []
for project_id, project_data in projects_dict.items():
custom_lines.append(lns.Line2D([0], [0], color=project_data['color'], lw=3))
custom_labels.append(project_data['label'])
axes.legend(custom_lines, custom_labels)
return axes
def __draw_track__(self, rhythm_track: Track, axes: plt.Axes, **kw):
# compute inter onset intervals and draw bars
ioi_vector = self.get_feature_extractor("ioi_vector").process(
rhythm_track)
return axes.bar(list(range(len(ioi_vector))),
ioi_vector,
width=0.95,
color=kw['color'])
def generate_correlation_plot(axes: plt.Axes, window_metrics: pd.DataFrame):
"""
Creates plot that demonstrates correlation between fixation counts and average fixation duration.
:param axes: the axes to plot on
:param window_metrics: the pre-cleaned data
:return: None
"""
plt.sca(axes)
min_fix_dur = window_metrics[AVERAGE_FIX_DUR].min() # left
max_fix_dur = window_metrics[AVERAGE_FIX_DUR].max() # right
min_fix_count = window_metrics[FIXATION_COUNTS].min() # bottom
max_fix_count = window_metrics[FIXATION_COUNTS].max() # top
axes.set_title("Overview of Participant Visual Effort")
x_mid = (max_fix_dur + min_fix_dur) // 2
y_mid = (max_fix_count + min_fix_count) // 2
# Background quadrant colors
bars = axes.bar(x=(x_mid, min_fix_dur, min_fix_dur, x_mid),
height=y_mid - min_fix_count,
bottom=(y_mid, y_mid, min_fix_count, min_fix_count),
width=x_mid - min_fix_dur,
color=get_quadrant_color_map().values(),
align='edge',
alpha=.3,
zorder=1)
# Vertical line for quadrants
axes.plot([x_mid, x_mid], [min_fix_count, max_fix_count],
color="black",
zorder=2)
# Horizontal line for quadrants
axes.plot([min_fix_dur, max_fix_dur], [y_mid, y_mid],
color="black",
zorder=3)
legend = plt.legend(
bars,
("Slow Comprehension\nComplexity\nImportance\nConfusion",
"Fast Comprehension\nSimplicity\nImportance\nPossible confusion",
"Fast Comprehension\nSimplicity\nUnimportance",
"Slow Comprehension\nComplexity\nUnimportance"),
loc='center left',
bbox_to_anchor=(1, 0.5))
for lh in legend.legendHandles:
lh.set_alpha(1)
axes.scatter(window_metrics[AVERAGE_FIX_DUR],
window_metrics[FIXATION_COUNTS],
zorder=4)
axes.set_xlabel("Mean Fixation Duration (ms)", fontsize="large")
axes.set_ylabel("Fixation Count", fontsize="large")
axes.autoscale(tight=True)
def bar_chart(ax: plt.Axes,
xvalues: list,
yvalues: list,
title: str,
xlabel: str,
ylabel: str,
percentage=False,
reverse=None):
ax.set_title(title)
ax.set_xlabel(xlabel)
ax.set_ylabel(ylabel)
if percentage:
ax.set_ylim(0.0, 1.0)
if reverse is not None:
yvalues, xvalues = zip(*sorted(zip(yvalues, xvalues), reverse=reverse))
ax.set_xticklabels(xvalues, rotation=90, fontsize='small')
ax.bar(xvalues, yvalues, edgecolor='grey')
plt.show()
def bar_chart(xvalues: list,
yvalues: list,
ax: plt.Axes = None,
title: str = '',
xlabel: str = '',
ylabel: str = '',
percentage=False,
hidegrid=False,
hide_xticklabels=False):
ax = set_axes(xvalues,
ax=ax,
title=title,
xlabel=xlabel,
ylabel=ylabel,
percentage=percentage,
hidegrid=hidegrid)
ax.bar(xvalues, yvalues, edgecolor=cfg.LINE_COLOR, color=cfg.FILL_COLOR)
if hide_xticklabels:
ax.set_xticklabels([])
def generate_fixation_plot(axes: plt.Axes, time: np.array,
window_metrics: pd.DataFrame):
"""
A handy method for generating the fixation plot.
:param window_metrics: a set of windowed data points
:param axes: the axes to plot on
:param time: the numpy array of times
:return: None
"""
plt.sca(axes)
axes.set_title("Eye Gaze Metrics with Visual Effort Transitions Over Time")
# Fixation count plot
color = 'tab:red'
axes.plot(time, window_metrics[FIXATION_COUNTS], color=color, linewidth=2)
axes.set_xlabel("Time (minutes)", fontsize="large")
axes.set_ylabel("Fixation Count", color=color, fontsize="large")
axes.tick_params(axis='y', labelcolor=color)
# Mean fixation duration plot
ax2 = axes.twinx()
color = 'tab:cyan'
ax2.plot(time, window_metrics[AVERAGE_FIX_DUR], color=color, linewidth=2)
ax2.set_ylabel("Mean Fixation Duration (ms)",
color=color,
fontsize="large")
ax2.set_ylim(bottom=100)
ax2.tick_params(axis='y', labelcolor=color)
# Background quadrants
minutes = int(WINDOW[:-1]) / 60
width = minutes
colors = get_quad_colors(window_metrics[QUADRANTS])
axes.bar(time,
window_metrics[FIXATION_COUNTS].max(),
alpha=.3,
width=width,
color=colors,
align="edge")
set_windowed_x_axis(axes)
def generate_click_stream_plot(axes: plt.Axes, stimulus_data: pd.DataFrame):
"""
Generates a line plot of all click stream related data.
:param stimulus_data: the raw stimulus data
:param axes: the axes to plot on
:return: None
"""
plt.sca(axes)
data = stimulus_data.groupby([pd.Grouper(freq=WINDOW),
MOUSE_EVENT])[MOUSE_EVENT].count().unstack()
click_stream = stimulus_data.resample(WINDOW)[[MOUSE_EVENT,
KEY_CODE]].count()
time = convert_date_to_time(click_stream.index)
minutes = int(WINDOW[:-1]) / 60
width = minutes
axes.bar(time,
click_stream[KEY_CODE].values,
width=width,
align="edge",
label="Keyboard Events",
edgecolor="black")
accumulator = click_stream[KEY_CODE].values
for column in data:
axes.bar(time,
data[column],
width=width,
align="edge",
bottom=accumulator,
label=column,
edgecolor="black")
accumulator += data[column]
# Clean up plot
axes.set_title("Click Stream Events Over Time", fontsize="large")
axes.set_xlabel("Time (minutes)", fontsize="large")
axes.set_ylabel("Click Stream Event Counts", fontsize="large")
set_windowed_x_axis(axes)
axes.legend()
def generate_gsr_peaks_plot(axes: plt.Axes, stimulus_data: pd.DataFrame):
"""
Plots range-corrected peaks over two-minute windows.
:param axes: the axes to plot on
:param stimulus_data: the raw stimulus data
:return: None
"""
plt.sca(axes)
windowed_data = stimulus_data.resample("2min").sum()[:15]
time = convert_date_to_time(windowed_data.index)
axes.set_title("Range-Corrected GSR Peaks Over Two-Minute Windows")
axes.set_xlabel("Time (minutes)", fontsize="large")
axes.set_ylabel("Peak Count")
set_windowed_x_axis(axes)
axes.bar(time,
windowed_data["peaks"],
width=2,
align="edge",
edgecolor="black")
def plot_coords(xs: Union[List[float], np.ndarray],
ys: Union[List[float], np.ndarray],
show: bool = None,
kind='line',
axes: plt.Axes = None,
**keys) -> None:
"""
Plot the points defined by xs and ys
Args:
xs: a seq. of x coords
ys: a seq. of y coords
kind: one of line or bar
axes: if given, this axes is used
kws: any keywords will be bassed to `axes.plot` or `axes.bar` depending
on `kind`
"""
if axes:
if kind == 'line':
axes.plot(xs, ys, **keys)
elif kind == 'bar':
axes.bar(xs, ys, **keys)
else:
if kind == 'line':
plt.plot(xs, ys, **keys)
elif kind == 'bar':
plt.bar(xs, ys, **keys)
plot_always_show = CONFIG['plot.always_show']
if plot_always_show and (show is None or show is True):
if axes:
axes.show()
else:
plt.show()
elif not plot_always_show and show is True:
plt.show()
def __draw_track__(self, rhythm_track: Track, axes: plt.Axes, **kw):
ioi_vector = self.get_feature_extractor("ioi_vector").process(
rhythm_track)
onset_positions = self.get_feature_extractor(
"onset_positions").process(rhythm_track)
# noinspection SpellCheckingInspection
styles = {
'edgecolor': kw['color'],
'facecolor': colors.to_rgba(kw['color'], 0.18),
'linewidth': 2.0
}
return axes.bar(onset_positions,
ioi_vector,
width=ioi_vector,
align="edge",
**styles)
def plot_distribution(
G: nx.Graph,
quantity,
as_probability_distribution=False,
axes: plt.Axes = None,
annotate=True,
as_partial=(1, 1),
attribute_name=None,
attribute_function=None,
attribute_function_name="",
attribute_parent="node",
axis_scaling="lin-lin",
bar_width_scaling=0.9,
bins=None,
label=None,
show_cumulative=False,
plot_options_dict: dict = None,
plot_type="scatter",
plotting_backend="matplotlib",
**kwargs,
):
# Check input for errors.
valid_quantities = (
"attribute",
"degree",
"in-degree",
"out-degree",
"shortest path length",
)
if quantity not in valid_quantities:
raise Exception('Invalid quantity: "' + quantity + '".')
# Load quantities.
if quantity == "attribute":
if attribute_function is None:
x_label = (
f"{attribute_parent.capitalize()} attribute: " f'"{attribute_name}"'
)
else:
x_label = (
f"{attribute_function_name}("
f"{attribute_parent} attribute: "
f'"{attribute_name}")'
)
if attribute_parent == "node":
if as_probability_distribution:
y_label = "Probability of attribute value"
else:
y_label = "Number of nodes"
else:
if as_probability_distribution:
y_label = "Probability of attribute value"
else:
y_label = "Number of edges"
title = f'Distribution of attribute: "{attribute_name}"'
if attribute_parent == "node":
attributes_dict = dict(nx.get_node_attributes(G, attribute_name))
attribute_values = list(attributes_dict.values())
elif attribute_parent == "edge":
attributes_dict = dict(nx.get_edge_attributes(G, attribute_name))
attribute_values = list(attributes_dict.values())
else:
raise ValueError(f'Invalid attribute object: "{attribute_parent}"')
if attribute_function is not None:
attribute_values = list(map(attribute_function, attribute_values))
# Make sure attribute values is a numpy array
attribute_values = np.array(attribute_values)
# Remove NaNs
nan_indices = np.isnan(attribute_values)
attribute_values = attribute_values[~nan_indices]
if bins is None:
distribution, bins = np.histogram(attribute_values)
else:
distribution, bins = np.histogram(attribute_values, bins=bins)
if as_probability_distribution:
distribution = distribution / len(attribute_values)
bin_centers = [np.mean([bins[i], bins[i + 1]]) for i in range(len(bins) - 1)]
elif quantity in ["degree", "in-degree", "out-degree"]:
x_label = "Node degree"
if as_probability_distribution:
y_label = "Probability of node degree"
else:
y_label = "Number of nodes"
if quantity == "degree":
direction = None
title = "Degree distribution"
elif quantity == "in-degree":
direction = "in"
title = "In-degree distribution"
elif quantity == "out-degree":
direction = "out"
title = "Out-degree distribution"
bin_centers, distribution = w.graph.degree_distribution(
G,
direction=direction,
as_probability_distribution=as_probability_distribution,
)
elif quantity == "shortest path length":
bin_centers, distribution = w.graph.shortest_path_length_distribution(
G, as_probability_distribution=as_probability_distribution
)
title = "Shortest path length distribution"
x_label = "Path length"
if as_probability_distribution:
y_label = "Probability of path length"
else:
y_label = "Number of paths"
# Plot
if plot_options_dict is None:
if plot_type == "scatter":
plot_options_dict = {
"marker": "o",
"markerfacecolor": "black",
"markersize": 3,
"linestyle": "None",
"linewidth": 0.5,
"color": "blue",
}
else:
plot_options_dict = dict()
if "color" in kwargs:
plot_options_dict["color"] = kwargs["color"]
if plot_type == "bar":
number_of_parts = as_partial[0]
part_number = as_partial[1]
width_bin = bin_centers[1] - bin_centers[0]
width_all_bars = bar_width_scaling * width_bin
width_bar = width_all_bars / number_of_parts
adjustment = (
np.linspace(0, width_all_bars, number_of_parts, endpoint=False)
- width_all_bars / 2
+ width_bar / 2
)[part_number - 1]
bin_centers = bin_centers + adjustment
if axis_scaling == "lin-lin":
if plot_type == "scatter":
x_start = min(bin_centers)
x_end = max(bin_centers)
elif plot_type == "bar":
x_start = min(bin_centers) + np.min(adjustment) - 1.5 * width_bar
x_end = max(bin_centers) + np.min(adjustment) + 1.5 * width_bar
elif axis_scaling == "log-log":
x_start = 1
x_end = 10 ** np.ceil(np.log10(max(bin_centers)))
if plotting_backend == "plotly":
# plotly needs the log10 of the range for logplots
x_start = np.log10(x_start)
x_end = np.log10(x_end)
else:
raise Exception('Unknown axis scaling: "' + axis_scaling + '"')
if plotting_backend == "matplotlib":
new_figure_created = False
if axes is None:
new_figure_created = True
figure = plt.figure()
figure.set_facecolor("white")
axes = figure.gca()
axes.set_facecolor("white")
if annotate:
axes.set_title(title)
axes.set_xlabel(x_label)
axes.set_ylabel(y_label)
if plot_type == "scatter":
axes.plot(bin_centers, distribution, label=label, **plot_options_dict)
axes.grid()
elif plot_type == "bar":
axes.bar(
bin_centers,
distribution,
width=width_bar,
label=label,
**plot_options_dict,
)
else:
raise Exception('Unknown plot type: "' + plot_type + '"')
axes.set_xlim(x_start, x_end)
if axis_scaling == "lin-lin":
pass
elif axis_scaling == "log-log":
axes.set_xscale("log")
axes.set_yscale("log")
else:
raise Exception('Unknown axis scaling: "' + axis_scaling + '"')
if show_cumulative:
cumulative_curve = axes.plot(
bin_centers, np.cumsum(distribution), color="#eb9b34"
)
axes.legend((cumulative_curve[0],), ("Cumulative",))
if as_partial[0] > 1:
axes.legend()
if new_figure_created:
w.format_figure(figure)
return axes
elif plotting_backend == "plotly":
if plot_type == "scatter":
traces = [
go.Scatter(
name="Distribution",
x=bin_centers,
y=distribution,
marker={"color": plot_options_dict["color"]},
mode="markers",
hovertemplate=f"{x_label}: %{{x}} <br> {y_label}: %{{y}}",
)
]
elif plot_type == "bar":
traces = [
go.Bar(
name="Distribution",
x=bin_centers,
y=distribution,
hovertemplate=f"{x_label}: %{{x}} <br> {y_label}: %{{y}}",
)
]
if show_cumulative:
traces += [
go.Scatter(
x=bin_centers,
y=np.cumsum(distribution),
name="Cumulative Distribution",
mode="lines",
hovertemplate=f"{x_label}: %{{x}} <br> Total {y_label}: %{{y}}",
)
]
figure = go.Figure(
data=traces,
layout=go.Layout(
title=title,
xaxis_title=x_label,
yaxis_title=y_label,
autosize=True,
width=800,
height=600,
showlegend=True,
margin={"l": 20, "r": 20, "t": 25, "b": 25},
xaxis={
"type": "log" if axis_scaling == "log-log" else "linear",
"range": [x_start, x_end],
},
yaxis={"type": "log" if axis_scaling == "log-log" else "linear"},
),
)
return figure
else:
raise AssertionError("plotting_backeng can only be 'matplotlib' or 'plotly'")
def __init__(
self,
counts: pd.DataFrame,
variable: str = "cases",
*,
strings: Translation = NullTranslation(),
normalize: bool = True,
age_group_size: int = 10,
window: int = 14,
population_distribution: pd.Series = None,
ax: plt.Axes = None,
resample_kwargs: Dict[str, Any] = {},
):
"""
Shows the age distribution of cases/deaths at a given date.
Usable either to draw a static chart or to generate an animation.
Args:
counts:
variable:
normalize:
age_group_size:
window:
population_distribution:
ax:
lang:
"""
self.ax = ax = ax or plt.gca()
s = strings
data = counts[variable].drop(columns="unknown")
data = ic.running_average(data, window=window, **resample_kwargs)
data = ic.aggregate_age_groups(data, cuts=age_group_size)
if normalize:
data = data.divide(data.sum(axis=1), axis=0)
ax.yaxis.set_major_formatter(
mpl.ticker.PercentFormatter(xmax=1.0, decimals=0))
self.data = data
if normalize and population_distribution is not None:
population = ic.aggregate_age_groups(population_distribution,
cuts=age_group_size)
sns.barplot(
ax=ax,
label=s["istat_population_data_label"],
x=population.index,
y=population,
facecolor='#a1c9f4',
hatch="/",
edgecolor="white",
)
age_groups = data.columns
label = s[f"{variable}_label"]
self.bars = ax.bar(
x=age_groups,
height=[0] * len(age_groups),
label=label,
facecolor='#4878d0',
alpha=0.7,
)
self.labels, self.update_labels = add_labels_to_bars(
self.bars,
fmt='{:.0%}' if normalize else '{:n}',
fontsize=10,
ax=ax,
color='white',
bbox=dict(
boxstyle=mpl.patches.BoxStyle("Round", pad=0.3),
color='black',
alpha=.35,
),
)
ymax = 1.05 * data.max().max()
ax.set_ylim(0, ymax)
ax.set_xticklabels(age_groups)
ax.set_xlabel(s["age"])
ax.set_ylabel("")
ax.grid(False, which='both', axis='x')
if normalize:
title = s.get(f"running_{variable}_age_distribution", count=window)
else:
title = s.get(f"running_average_{variable}_title", count=window)
ax.set_title(title, fontsize=14)
if normalize and population_distribution is not None:
ax.yaxis.set_major_formatter(
mpl.ticker.PercentFormatter(xmax=1.0, decimals=0))
ax.legend()
self.date_text = ax.text(
0.5,
0.93,
"",
ha="center",
va="center",
transform=ax.transAxes,
color=(1, 1, 1, 0.9),
bbox=dict(
boxstyle=mpl.patches.BoxStyle("Round", pad=0.4),
color=(0, 0, 0, 0.30),
),
fontsize=14,
fontweight="semibold",
)
self.artists = [self.date_text, *self.bars, *self.labels]
def plot_degree_distribution(G: nx.Graph,
direction: str = None,
as_probability_distribution=False,
axes: plt.Axes = None,
annotate=['all'],
label=None,
axis_scaling='lin-lin',
show_cumulative=False,
plot_options_dict: dict = None,
plot_type='scatter',
**kwargs):
if isinstance(annotate, str):
annotate = [annotate]
# Histogram
degrees, distribution = w.graph.degree_distribution(
G,
direction=direction,
as_probability_distribution=as_probability_distribution)
# Plot
if plot_options_dict is None:
if plot_type == 'scatter':
plot_options_dict = \
{'marker': 'o', 's': 3, 'c': 'blue'}
elif plot_type == 'bar':
plot_options_dict = {'color': 'blue'}
else:
plot_options_dict = dict()
if 'color' in kwargs:
if plot_type == 'scatter':
plot_options_dict['c'] = kwargs['color']
else:
plot_options_dict['color'] = kwargs['color']
if 'marker_size' in kwargs:
if plot_type == 'scatter':
plot_options_dict['s'] = kwargs['marker_size']
new_figure_created = False
if axes is None:
new_figure_created = True
figure = plt.figure()
figure.set_facecolor('white')
axes = figure.gca()
axes.set_facecolor('white')
if direction is None:
title = 'Degree distribution'
elif direction == 'in':
title = 'In-degree distribution'
elif direction == 'out':
title = 'Out-degree distribution'
else:
raise Exception('Invalid direction: "' + direction + '"')
if as_probability_distribution:
y_label = 'Probability of node degree'
else:
y_label = 'Number of nodes'
if ('title' in annotate) or ('all' in annotate):
axes.set_title(title)
if ('x_label' in annotate) or ('all' in annotate):
axes.set_xlabel('Node degree')
if ('y_label' in annotate) or ('all' in annotate):
axes.set_ylabel(y_label)
if plot_type == 'scatter':
plot = axes.scatter(degrees,
distribution,
label=label,
**plot_options_dict)
axes.grid()
elif plot_type == 'bar':
plot = axes.bar(degrees,
distribution,
label=label,
**plot_options_dict)
else:
raise Exception('Unknown plot type: "' + plot_type + '"')
if axis_scaling == 'lin-lin':
if plot_type == 'scatter':
axes.set_xlim(0, max(degrees))
elif plot_type == 'bar':
axes.set_xlim(-1, max(degrees))
elif axis_scaling == 'log-log':
axes.set_xscale('log')
axes.set_yscale('log')
axes.set_xlim(0.8, 10**np.ceil(np.log10(max(degrees))))
else:
raise Exception('Unknown axis scaling: "' + axis_scaling + '"')
if show_cumulative:
cumulative_curve = axes.plot(degrees,
np.cumsum(distribution),
color='#eb9b34')
axes.legend((cumulative_curve[0], ), ('Cumulative', ))
if new_figure_created:
w.format_figure(figure)
return axes, (degrees, distribution)
def plot_histogram_to_ax(ax: plt.Axes, histogram):
ax.bar(list(histogram.keys()), list(histogram.values()))
ax.ticklabel_format(style="sci", axis="y", scilimits=(0, 0))
ax.set_ylabel("Number of MPR Pairs")
def plot_f1_metrics(run_histories: List[Run],
experiment_name: str,
metric_names: Dict[str, str],
target_file_paths: Optional[List[str]] = None,
axis: plt.Axes = None,
y_lims: Tuple[float, float] = None,
mode='box',
add_legend=True,
color=None):
standalone_mode = axis is None
if color is None:
# by default we use bright orange from map 'tab20c'
color = plt.get_cmap('tab20c')(4)
runs_data = []
for run_history in run_histories:
metrics_data = []
for metric_name in metric_names.keys():
metric_data = []
for fold_history in run_history.fold_histories:
# add the metric for the last epoch
metric_data.append(fold_history.epochs[-1].metrics[metric_name])
metric_data = np.array(metric_data)
if mode == 'bar':
metric_data = np.mean(metric_data)
metrics_data.append(metric_data)
runs_data.append(metrics_data)
with plt.style.context('seaborn'):
if axis is None:
fig: plt.Figure = plt.figure()
fig.suptitle(experiment_name, fontsize=24)
axis = fig.add_subplot(111)
else:
axis.set_title(experiment_name, fontsize=22)
axis.set_ylabel('Metric Value', fontsize=22)
if y_lims is not None:
print('limits', y_lims)
axis.set_ylim(*y_lims)
num_metrics = None
num_runs = len(runs_data)
for i, metrics_data in enumerate(runs_data):
num_metrics = len(metrics_data)
xs = range(i * len(metrics_data) + i, (i + 1) * len(metrics_data) + i)
max_v = .9
min_v = .6
colors = []
for idx in range(num_metrics):
if num_metrics > 1:
norm = idx * (max_v - min_v) / (num_metrics - 1)
else:
norm = 0
fill_color = list(colorsys.rgb_to_hls(*mc.to_rgb(color)))
fill_color[1] = min_v + norm
colors.append((
color,
colorsys.hls_to_rgb(*fill_color)
))
line_styles = ['-', '-.', ':', '--']
if mode == 'box':
boxplots = axis.boxplot(
metrics_data,
meanline=True,
showmeans=True,
positions=xs,
widths=0.6,
patch_artist=True
)
for plot_idx in range(num_metrics):
dark_color = colors[plot_idx][0]
light_color = colors[plot_idx][1]
plt.setp(boxplots['boxes'][plot_idx], color=dark_color)
plt.setp(boxplots['boxes'][plot_idx], facecolor=light_color)
plt.setp(boxplots['boxes'][plot_idx], linestyle=line_styles[plot_idx])
plt.setp(boxplots['whiskers'][plot_idx * 2], color=dark_color)
plt.setp(boxplots['whiskers'][plot_idx * 2 + 1], color=dark_color)
plt.setp(boxplots['whiskers'][plot_idx * 2], linestyle=line_styles[plot_idx])
plt.setp(boxplots['whiskers'][plot_idx * 2 + 1], linestyle=line_styles[plot_idx])
plt.setp(boxplots['caps'][plot_idx * 2], color=dark_color)
plt.setp(boxplots['caps'][plot_idx * 2 + 1], color=dark_color)
plt.setp(boxplots['fliers'][plot_idx], markeredgecolor=dark_color)
plt.setp(boxplots['fliers'][plot_idx], marker='x')
plt.setp(boxplots['medians'][plot_idx], color=dark_color)
plt.setp(boxplots['means'][plot_idx], color=dark_color)
legend_styles = [boxplots['boxes'][idx] for idx in range(num_metrics)]
elif mode == 'bar':
legend_styles = []
for plot_idx in range(num_metrics):
ret = axis.bar(xs[plot_idx], metrics_data[plot_idx],
color=colors[plot_idx][1],
edgecolor=colors[plot_idx][0],
width=0.6,
linewidth=1.25,
linestyle=line_styles[plot_idx], )
legend_styles.append(ret)
tick_offset = num_metrics * 0.5 - 0.5
ticks = np.arange(start=tick_offset, stop=num_runs * num_metrics + num_runs + tick_offset,
step=num_metrics + 1.0)
axis.set_xticks(ticks)
for yticklabel in axis.get_yticklabels():
yticklabel.set_fontsize(20)
axis.set_xticklabels([r.name for r in run_histories], fontsize=20, rotation=0)
if add_legend:
axis.legend(legend_styles, metric_names.values(),
loc='lower right', fontsize=16,
facecolor="white", frameon=True,
edgecolor="black")
if standalone_mode:
fig.show()
if target_file_paths is not None:
for target_file_path in target_file_paths:
fig.savefig(target_file_path)
return legend_styles
def plot_string_histogram(string_list: List[str], title: str, axis: plt.Axes):
"""Plot frequency of unique strings in list in matplotlib axis."""
logging.info("Plotting frequency of unique strings")
letter_counts = dict(collections.Counter(string_list))
axis.bar(letter_counts.keys(), letter_counts.values())
axis.set_title(title)
def __draw_track__(self, rhythm_track: Track, axes: plt.Axes, **kw):
occurrences, interval_durations = self.get_feature_extractor(
"ioi_histogram").process(rhythm_track)
return axes.bar(interval_durations, occurrences, color=kw['color'])
def errorbox(
plot: plt.Axes,
plot_def: PlotDef,
xaxis: Tuple[str, str],
yaxis: Tuple[str, str],
firstcolor: int = 0,
firstshape: int = 0,
markersize: int = 6,
use_cross: bool = False,
) -> Optional[mpl.legend.Legend]:
"""Generate a figure with errorboxes that reflect the std dev of an entry.
Args:
plot: a pyplot Axes object
plot_def: a `PlotDef` that defines properties of the plot
xaxis: a tuple of two strings
yaxis: a tuple of two strings
firstcolor: index of the color that should be used for the first entry
firstshape: index of the shape that should be used for the first entry
markersize: size of the markers
use_cross: if True, use cross instead of boxes
"""
# ================================ constants for plots ========================================
colors = ["#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd"]
colors += ["#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf"]
pale_colors = ["#aec7e8", "#ffbb78", "#98df8a", "#ff9896", "#c5b0d5"]
pale_colors += ["#c49c94", "#f7b6d2", "#c7c7c7", "#dbdb8d", "#9edae5"]
shapes = ["o", "X", "D", "s", "^", "v", "<", ">", "*", "p", "P"]
hatch_pattern = ["O", "o", "|", "-", "/", "\\", "+", "x", "*"]
xaxis_measure, yaxis_measure = xaxis[0], yaxis[0]
filled_counter = firstcolor
max_xmean = 0.0
min_xmean = 1.0
max_ymean = 0.0
min_ymean = 1.0
for i, entry in enumerate(plot_def.entries):
if entry.do_fill:
color = colors[filled_counter]
filled_counter += 1
else:
color = pale_colors[i + firstcolor - filled_counter]
i_shp = firstshape + i
xmean: float = entry.values[xaxis_measure].mean()
xstd: float = entry.values[xaxis_measure].std()
if xmean + (0.5 * xstd) > max_xmean:
max_xmean = xmean + (0.5 * xstd)
if xmean - (0.5 * xstd) < min_xmean:
min_xmean = xmean - (0.5 * xstd)
ymean: float = entry.values[yaxis_measure].mean()
ystd: float = entry.values[yaxis_measure].std()
if ymean + (0.5 * ystd) > max_ymean:
max_ymean = ymean + (0.5 * ystd)
if ymean - (0.5 * ystd) < min_ymean:
min_ymean = ymean - (0.5 * ystd)
if use_cross:
plot.errorbar(
xmean,
ymean,
xerr=0.5 * xstd,
yerr=0.5 * ystd,
marker=shapes[i_shp % len(shapes)],
linestyle="", # no connecting lines
color=color,
ecolor="#555555",
capsize=4,
elinewidth=1.0,
zorder=3 + 2 * i_shp,
label=entry.label,
markersize=markersize,
)
else:
plot.bar(
xmean,
ystd,
bottom=ymean - 0.5 * ystd,
width=xstd,
align="center",
color="none",
edgecolor=color,
linewidth=3,
zorder=3 + 2 * i_shp,
hatch=hatch_pattern[i % len(hatch_pattern)],
)
plot.plot(
xmean,
ymean,
marker=shapes[i_shp % len(shapes)],
linestyle="", # no connecting lines
color=color,
label=entry.label,
zorder=4 + 2 * i_shp,
markersize=markersize,
)
x_min = min_xmean * 0.99
x_max = max_xmean * 1.01
y_min = min_ymean * 0.99
y_max = max_ymean * 1.01
plot.set_xlim(x_min, x_max)
plot.set_ylim(y_min, y_max)
return common_plotting_settings(plot, plot_def, xaxis[1], yaxis[1])
def bar_chart(xvalues: list, yvalues: list, ax: plt.Axes = None, title: str = '',
xlabel: str = '', ylabel: str = '', percentage=False):
ax = set_axes(xvalues, ax=ax, title=title, xlabel=xlabel, ylabel=ylabel, percentage=percentage)
ax.bar(xvalues, yvalues, edgecolor='#0C70B2', color='#BDDDE0')
