def _generate_activity_count_plot(activity_data: pd.DataFrame, ax: mpl.axes.Axes, colours: str): """ Generate a bar plot of activity counts over time (by type). Arguments: activity data - A pandas DataFrame containing the activity data. ax - A set of matplotlib axes to generate the plot on. colours - A name of the colour palette to generate the plot with. """ # Group the activity data by month and calculate the count of each activity type data = (activity_data.groupby([activity_data.index.to_period('M'), 'type' ]).size().to_frame('count').reset_index()) # Generate and format the bar plot sns.barplot(x='start_date_local', y='count', hue='type', data=data, palette=colours, ax=ax) ax.set(title='Activities over time', ylabel='Number of activities', xlabel='Month') ax.set_xticklabels(ax.get_xticklabels(), rotation=45, horizontalalignment='right') ax.get_xaxis().set_minor_locator(mpl.ticker.AutoMinorLocator()) ax.get_yaxis().set_minor_locator(mpl.ticker.AutoMinorLocator()) ax.grid(b=True, which='major', linewidth=1.0) ax.yaxis.grid(b=True, which='minor', linewidth=0.5) ax.set_axisbelow(True)
def _generate_commute_count_plot(commute_data: pd.DataFrame, ax: mpl.axes.Axes, colours: dict): """ Generate a bar plot of number of commutes per month. Arguments: commute_data - A pandas DataFrame containing the commute activity data. ax - A set of matplotlib axes to generate the plot on. colours - A dictionary of colours to generate the plot with. """ # Group the commute data by month data = commute_data.resample('M').count() # Generate and format the bar plot sns.barplot(x=data.index.to_period('M'), y=data['distance'], color=colours['commute_count'], ax=ax) ax.set(ylabel='Number of commutes', xlabel='Month') ax.set_xticklabels(ax.get_xticklabels(), rotation=45, horizontalalignment='right') ax.get_xaxis().set_minor_locator(mpl.ticker.AutoMinorLocator()) ax.get_yaxis().set_minor_locator(mpl.ticker.AutoMinorLocator()) ax.grid(b=True, which='major', linewidth=1.0) ax.yaxis.grid(b=True, which='minor', linewidth=0.5) ax.set_axisbelow(True)
def _generate_mean_distance_plot(activity_data: pd.DataFrame, ax: mpl.axes.Axes, colour_palette: list): """ Generate a bar plot of mean activity distance over time (by type). Arguments: activity data - A pandas DataFrame containing the activity data. ax - A set of matplotlib axes to generate the plot on. colour_palette - The colour palette to generate the plot with. """ # Group the activity data by month and calculate the mean distance of each activity type data = activity_data.groupby([activity_data.index.to_period('Y'), 'type']).mean().reset_index() # Generate and format the bar plot sns.barplot(x='start_date_local', y='distance', hue='type', data=data, palette=colour_palette, ax=ax) ax.set(title='Mean activity distance over time', ylabel='Mean distance (km)', xlabel='Year') ax.set_xticklabels(ax.get_xticklabels(), rotation=45, horizontalalignment='right') ax.get_xaxis().set_minor_locator(mpl.ticker.AutoMinorLocator()) ax.get_yaxis().set_minor_locator(mpl.ticker.AutoMinorLocator()) ax.grid(b=True, which='major', linewidth=1.0) ax.yaxis.grid(b=True, which='minor', linewidth=0.5) ax.set_axisbelow(True)
def _generate_commute_days_plot(commute_data: pd.DataFrame, ax: mpl.axes.Axes, colours: dict): """ Generate a line plot of commute days per year. Arguments: commute_data - A pandas DataFrame containing the commute activity data. ax - A set of matplotlib axes to generate the plot on. colours - A dictionary of colours to generate the plot with. """ # Group the commute data by day data = commute_data.groupby(commute_data.index.to_period('D')).agg( {'distance': 'mean'}) # Generate and format the line plot sns.lineplot(x=data.index.year.value_counts().index, y=data.index.year.value_counts(), color=colours['commute_days'], marker='o', ax=ax) ax.set(ylabel='Commute days', xlabel='Year') ax.get_xaxis().set_minor_locator(mpl.ticker.AutoMinorLocator()) ax.get_yaxis().set_minor_locator(mpl.ticker.AutoMinorLocator()) ax.grid(b=True, which='major', linewidth=1.0) ax.yaxis.grid(b=True, which='minor', linewidth=0.5)
def draw_tables(ax: matplotlib.axes.Axes, net: torch.nn.Module, data: tg.data.DataLoader): table = np.full((13, 12), np.nan) for batch in data: predicted = net(batch) Y = batch.y[:, 0] - 2008 M = batch.y[:, 1] table[Y, M] = cycle_dst2(M.float(), predicted.flatten().detach().numpy())**.5 mshow = ax.matshow(table, vmin=0, vmax=6) ax.set(yticks=range(13), yticklabels=range(2008, 2021)) return mshow
def post_process_plt(df: pd.DataFrame, ax: plt.axes.Axes, percent: bool = False) -> plt.figure.Figure: """Post-process the Matplotlib Axes instance produced by :func:`pre_process_plt`. The post-processing invovles further formatting of the legend, the x-axis and the y-axis. Parameters ---------- df : :class:`pandas.DataFrame` A DataFrame holding the accumulated SBU usage. See :func:`pre_process_df` and :func:`.get_agregated_sbu`. ax : :class:`matplotlib.Axes<matplotlib.axes.Axes>` An Axes instance produced by :func:`pre_process_plt`. percent : class`bool` If ``True``, apply additional formatting for handling percentages. Returns ------- :class:`matplotlib.figure.Figure`: A Matplotlib Figure constructed from **ax**. """ df_max = df.max().max() decimals = 1 - len(str(int(df.values.max()))) y_max = round(df_max, decimals) + 10**-decimals # Format the y-axis ax.yaxis.set_major_formatter(plt.ticker.StrMethodFormatter('{x:,.0f}')) ax.set(ylim=(0, y_max)) # Format the x-axis i = len(df.index) // 6 or 1 ax.set(xticks=df.index[0::i]) today = date.today().strftime('%d %b %Y') if percent: ax.set_ylabel('SBUs (System Billing Units) / %') ax.set_title('Accumulated % SBU usage: {}'.format(today), fontdict={'fontsize': 18}) ax.legend_.set_title('Project (PI): % SBU') else: ax.set_ylabel('SBUs (System Billing Units) / hours') ax.set_title('Accumulated SBU usage: {}'.format(today), fontdict={'fontsize': 18}) ax.legend_.set_title('Project (PI): SBU') return ax.get_figure()
def plot( self, xlabel: str = "Method difference", ylabel: str = "Folded CDF (%)", label: str = "$M_1$ - $M_2$", unit: str = None, title: str = None, color: str = "blue", legend: bool = True, square: bool = False, show_hline: bool = True, show_vlines: bool = True, show_markers: bool = True, ax: matplotlib.axes.Axes = None, ) -> matplotlib.axes.Axes: """Plot mountain plot Parameters ---------- xlabel : str, optional The label which is added to the X-axis. (default: "Method difference") ylabel : str, optional The label which is added to the Y-axis. (default: "Folded CDF (%)") label : str, optional mountaint line legend label (default:"Method 1 - Method 2" ) unit : str, optional unit to disply for x-axis title : str, optional figure title, if none there will be no title (default: None) legend : bool, optional If True, will provide a legend containing the computed regression equation. (default: True) square : bool, optional If True, set the Axes aspect to "equal" so each cell will be square-shaped. (default: True) color : str, optional Color for mountain plot elements show_hline: bool, optional If set show horizontal lines for iqr show_vlines: bool, optional If set show vertical lines at iqr and median show_markers: bool, optional If set show markers at iqr and median ax : matplotlib.axes.Axes, optional matplotlib axis object, if not passed, uses gca() Returns ------- matplotlib.axes.Axes axes object with the plot """ ax = ax or plt.gca() ax.step( y=self.result["mountain"], x=self.result["quantile"], where="mid", label=f"{label} AUC={self.result['auc']:.2f}", color=color, ) if show_hline: ax.hlines( self.result["mountain_iqr"], xmin=self.result["iqr"][0], xmax=self.result["iqr"][1], color=color, ) if show_vlines: ax.vlines( self.result["median"], ymin=0, ymax=50, label=f"median={self.result['median']:.2f} {unit or ''}", linestyle="--", color=color, ) if self.iqr > 0: ax.vlines( self.result["iqr"], ymin=0, ymax=50 - self.iqr / 2, label=( f"{self.iqr:.2f}% IQR =" f"{self.result['iqr'][1] - self.result['iqr'][0]:.2f}" "{unit or ''}"), linestyle=":", color=color, ) if show_markers: ax.plot( self.result["median"], self.result["mountain_median"], "o", color=color, ) if self.iqr > 0: ax.plot( self.result["iqr"], self.result["mountain_iqr"], "o", color=color, ) u = f"({unit})" if unit else "" ax.set(xlabel=f"{xlabel} {u}", ylabel=ylabel or None, title=title or None) ax.legend(loc="upper left", fontsize="medium") if legend: ax.legend(loc="upper left", frameon=False) if square: ax.set_aspect("equal") return ax
def plot( self, x_label: str = "Method 1", y_label: str = "Method 2", title: str = None, line_reference: bool = True, line_CI: bool = True, legend: bool = True, square: bool = False, ax: matplotlib.axes.Axes = None, point_kws: Optional[Dict] = None, color_regr: Optional[str] = None, alpha_regr: Optional[float] = None, ) -> matplotlib.axes.Axes: """Plot regression result Parameters ---------- x_label : str, optional The label which is added to the X-axis. (default: "Method 1") y_label : str, optional The label which is added to the Y-axis. (default: "Method 2") title : str, optional Title of the regression plot. If None is provided, no title will be plotted. line_reference : bool, optional If True, a grey reference line at y=x will be plotted in the plot (default: True) line_CI : bool, optional If True, dashed lines will be plotted at the boundaries of the confidence intervals. (default: False) legend : bool, optional If True, will provide a legend containing the computed regression equation. (default: True) square : bool, optional If True, set the Axes aspect to "equal" so each cell will be square-shaped. (default: True) ax : matplotlib.axes.Axes, optional matplotlib axis object, if not passed, uses gca() point_kws : Optional[Dict], optional Additional keywords to plt color_regr : Optional[str], optional color for regression line and CI area alpha_regr : Optional[float], optional alpha for regression CI area Returns ------------------ matplotlib.axes.Axes axes object with the plot """ ax = ax or plt.gca() # Set scatter plot keywords to defaults and apply override pkws = self.DEFAULT_POINT_KWS.copy() pkws.update(point_kws or {}) # Get regression parameters slope = self.result["slope"] intercept = self.result["intercept"] # plot individual points ax.scatter(self.method1, self.method2, **pkws) # plot reference line if line_reference: ax.plot( [0, 1], [0, 1], label="Reference", color="grey", linestyle="--", transform=ax.transAxes, ) # Compute x and y values xvals = np.array(ax.get_xlim()) yvals = xvals[:, None] * slope + intercept # Plot regression line 0 ax.plot( xvals, yvals[:, 0], label= f"{y_label} = {intercept[0]:.2f} + {slope[0]:.2f} * {x_label}", color=color_regr, linestyle="-", ) # Plot confidence region if yvals.shape[1] > 2: ax.fill_between( xvals, yvals[:, 1], yvals[:, 2], color=color_regr or self.DEFAULT_REGRESSION_KWS["color"], alpha=alpha_regr or self.DEFAULT_REGRESSION_KWS["alpha"], ) if line_CI: ax.plot(xvals, yvals[:, 1], linestyle="--") ax.plot(xvals, yvals[:, 2], linestyle="--") # Set axes labels ax.set( xlabel=x_label or "", ylabel=y_label or "", title=title or "", ) if legend: ax.legend(loc="upper left", frameon=False) if square: ax.set_aspect("equal") return ax
def plot( self, x_label: str = "Mean of methods", y_label: str = "Difference between methods", graph_title: str = None, reference: bool = False, xlim: Tuple = None, ylim: Tuple = None, color_mean: str = "#008bff", color_loa: str = "#FF7000", color_points: str = "#000000", point_kws: Dict = None, ci_alpha: float = 0.2, loa_linestyle: str = "--", ax: matplotlib.axes.Axes = None, ): """Provide a method comparison using Bland-Altman plotting. This is an Axis-level function which will draw the Bland-Altman plot onto the current active Axis object unless ``ax`` is provided. Parameters ---------- x_label : str, optional The label which is added to the X-axis. If None is provided, a standard label will be added. y_label : str, optional The label which is added to the Y-axis. If None is provided, a standard label will be added. graph_title : str, optional Title of the Bland-Altman plot. If None is provided, no title will be plotted. reference : bool, optional If True, a grey reference line at y=0 will be plotted in the Bland-Altman. xlim : list, optional Minimum and maximum limits for X-axis. Should be provided as list or tuple. If not set, matplotlib will decide its own bounds. ylim : list, optional Minimum and maximum limits for Y-axis. Should be provided as list or tuple. If not set, matplotlib will decide its own bounds. color_mean : str, optional Color of the mean difference line that will be plotted. color_loa : str, optional Color of the limit of agreement lines that will be plotted. color_points : str, optional Color of the individual differences that will be plotted. point_kws : dict of key, value mappings, optional Additional keyword arguments for `plt.scatter`. ci_alpha: float, optional Alpha value of the confidence interval. loa_linestyle: str, optional Linestyle of the limit of agreement lines. ax : matplotlib Axes, optional Axes in which to draw the plot, otherwise use the currently-active Axes. Returns ------- ax : matplotlib Axes Axes object with the Bland-Altman plot. """ ax = ax or plt.gca() pkws = self.DEFAULT_POINTS_KWS.copy() pkws.update(point_kws or {}) # Get parameters mean, mean_CI = self.result["mean"], self.result["mean_CI"] loa_upper, loa_upper_CI = self.result["loa_upper"], self.result[ "loa_upper_CI"] loa_lower, loa_lower_CI = self.result["loa_lower"], self.result[ "loa_lower_CI"] sd_diff = self.result["sd_diff"] # individual points ax.scatter(self.mean, self.diff, **pkws) # mean difference and SD lines ax.axhline(mean, color=color_mean, linestyle=loa_linestyle) ax.axhline(loa_upper, color=color_loa, linestyle=loa_linestyle) ax.axhline(loa_lower, color=color_loa, linestyle=loa_linestyle) if reference: ax.axhline(0, color="grey", linestyle="-", alpha=0.4) # confidence intervals (if requested) if self.CI is not None: ax.axhspan(*mean_CI, color=color_mean, alpha=ci_alpha) ax.axhspan(*loa_upper_CI, color=color_loa, alpha=ci_alpha) ax.axhspan(*loa_lower_CI, color=color_loa, alpha=ci_alpha) # text in graph trans: matplotlib.transform = transforms.blended_transform_factory( ax.transAxes, ax.transData) offset: float = (((self.loa * sd_diff) * 2) / 100) * 1.2 ax.text( 0.98, mean + offset, "Mean", ha="right", va="bottom", transform=trans, ) ax.text( 0.98, mean - offset, f"{mean:.2f}", ha="right", va="top", transform=trans, ) ax.text( 0.98, loa_upper + offset, f"+{self.loa:.2f} SD", ha="right", va="bottom", transform=trans, ) ax.text( 0.98, loa_upper - offset, f"{loa_upper:.2f}", ha="right", va="top", transform=trans, ) ax.text( 0.98, loa_lower - offset, f"-{self.loa:.2f} SD", ha="right", va="top", transform=trans, ) ax.text( 0.98, loa_lower + offset, f"{loa_lower:.2f}", ha="right", va="bottom", transform=trans, ) # transform graphs ax.spines["right"].set_visible(False) ax.spines["top"].set_visible(False) # set X and Y limits if xlim is not None: ax.set_xlim(xlim[0], xlim[1]) if ylim is not None: ax.set_ylim(ylim[0], ylim[1]) # graph labels ax.set(xlabel=x_label, ylabel=y_label, title=graph_title) return ax