def subplot_setter(ax: plt.Axes, vis_settings: VisualizerSettings, subplot_settings: SubplotSettings) -> None: tick_params = { "labelleft": subplot_settings.labelleft, "left": subplot_settings.left, "labelbottom": subplot_settings.labelbottom, "bottom": subplot_settings.bottom } ax.tick_params(**tick_params) if subplot_settings.xlabel is not None: ax.set_xlabel(subplot_settings.xlabel) if subplot_settings.ylabel is not None: ax.set_ylabel(subplot_settings.ylabel) if subplot_settings.xlim is not None: ax.set_xlim(subplot_settings.xlim) if subplot_settings.ylim is not None: ax.set_ylim(subplot_settings.ylim) if subplot_settings.legend: ax.legend() if vis_settings.grid: ax.grid() if subplot_settings.log_scale: ax.set_yscale("log")
def _plot_monthly_averages(ax: pl.Axes, data: pd.DataFrame) -> None: # Calculate cumulative snow totals per month in each year data["Cumulative Snow"] = (data["SNOW"].groupby( [data.index.year, data.index.month]).cumsum()) # Average these things by month over all years avg_per_month = data.groupby( data.index.month).mean()[["Cumulative Snow", "TAVG", "TMAX", "TMIN"]] # This is to cycle the whole DF so July is at the start dummy_sort_key = "dummy" avg_per_month[dummy_sort_key] = np.roll(avg_per_month.index, 6) avg_per_month.sort_values(dummy_sort_key, inplace=True) avg_per_month.drop(dummy_sort_key, axis=1, inplace=True) # Replace index month numbers with month names avg_per_month.set_index( pd.to_datetime(avg_per_month.index, format="%m").strftime("%b"), inplace=True, ) # Plot avg_per_month.plot.bar( ax=ax, secondary_y=[ col for col in avg_per_month.columns if col != "Cumulative Snow" ], ) ax.grid(True) ax.right_ax.grid(False) ax.set_xlabel("Month") ax.set_ylabel("Snowfall (Inches)") ax.right_ax.set_ylabel("Temperature (F)")
def animate_pendulum(ax: plt.Axes, t: np.array, sol: np.array, l=1): ''' animate pendulum model :param t: (N) time value :param sol: (N, 2) odeint solution sol[:, 0] is the angular position, sol[:, 1] is the angular rate :return: list of plot elements ''' plt.rcParams['font.size'] = 15 lns = [] for i in range(len(sol)): ln, = ax.plot([0, l * np.sin(sol[i, 0] + np.pi)], [0, -l * np.cos(sol[i, 0] + np.pi)], color='k', lw=2) pt = ax.scatter([l * np.sin(sol[i, 0] + np.pi)], [-l * np.cos(sol[i, 0] + np.pi)], s=100, c='k') tm = ax.text(-l, 0.9 * l, 'time = %.1fs' % t[i]) lns.append([ln, pt, tm]) margin = np.abs(l) * 0.05 ax.set_xlim(-l - margin, l + margin) ax.set_ylim(-l - margin, l + margin) ax.grid() return lns
def format_axes( ax: plt.Axes, ticklabels, patch_size, total_size, block_size, ): robust_models = [1, 2] ax_mm_ticks = np.arange(0, total_size, block_size) ax.set_xticks(ax_mm_ticks - 0.5) ax.set_yticks(ax_mm_ticks - 0.5) ax.set_xticklabels(ax_mm_ticks) ax.set_yticklabels(ax_mm_ticks) ax.grid(which='major', axis='both', lw=1, color='k', alpha=0.5, ls='-') ax.set_xticks(ax_mm_ticks + block_size / 2, minor=True) ax.set_yticks(ax_mm_ticks + block_size / 2, minor=True) ax.set_xticklabels([]) ax.set_yticklabels([]) ax.set_xticklabels(ticklabels, minor=True, fontsize=12, weight='light') ax.set_yticklabels(ticklabels, minor=True, fontsize=12, weight='light') plt.setp(ax.get_yticklabels(minor=True), rotation=90, ha="center", va="bottom", rotation_mode="anchor") # ax.set_title(f'Patch Size {patch_size}', fontsize=1, pad=10) ax.set_xlabel('Models', fontsize=14) ax.set_ylabel('Models', fontsize=14) ax.xaxis.labelpad = 7 ax.yaxis.labelpad = 7
def group_plot(axis: plt.Axes, title: str, names: List[str], ratios: List[Dict[AgentType, List[float]]]): """Generate a joint plot for a benchmark result group on `axis`""" axis.set_title(title) axis.set_xlabel("Time") axis.set_ylabel("Safe agents (%)") axis.set_yticks(range(0, 101, 10)) axis.grid(True) legend: Tuple[List[plt.Line2D], List[str]] = ([], []) dark = get_cmap("Dark2") for i, rs in enumerate(ratios): line_name = names[i].split("_")[-1] for (j, typ) in enumerate(rs): data = list(map(lambda x: x * 100, rs[typ])) xdata = data[:data.index(100) + 1] axis.plot(xdata, color=dark(i), linestyle=AGENT_STYLES[typ.name], linewidth=2) if j == 0: legend_line = plt.Line2D(xdata, range(0, len(xdata)), color=dark(i), linestyle="solid") legend[0].append(legend_line) legend[1].append(line_name) axis.legend(*legend, loc=4, fontsize="large")
def common_plotting_settings(plot: plt.Axes, plot_def: PlotDef, xaxis_title: str, yaxis_title: str) -> Optional[mpl.legend.Legend]: """Common settings for plots. Args: plot: a pyplot plot object plot_def: a `PlotDef` that defines properties of the plot xaxis_title: label for x-axis yaxis_title: label for y-axis """ plot.set_xlabel(xaxis_title) plot.set_ylabel(yaxis_title) if plot_def.title: plot.set_title(plot_def.title) plot.grid(True) # get handles and labels for the legend handles, labels = plot.get_legend_handles_labels() # remove the errorbars from the legend if they are there handles = [(h[0] if isinstance(h, tuple) else h) for h in handles] if plot_def.legend_pos == "inside": return plot.legend(handles, labels) if plot_def.legend_pos == "outside": return plot.legend(handles, labels, loc="upper left", bbox_to_anchor=(1, plot_def.legend_yanchor)) return None
def plot_ghi_curves( clearsky_ghi: np.ndarray, station_ghi: np.ndarray, pred_ghi: typing.Optional[np.ndarray], window_start: datetime.datetime, window_end: datetime.datetime, sample_step: datetime.timedelta, horiz_offset: datetime.timedelta, ax: plt.Axes, station_name: typing.Optional[typing.AnyStr] = None, station_color: typing.Optional[typing.AnyStr] = None, current_time: typing.Optional[datetime.datetime] = None, ) -> plt.Axes: """Plots a set of GHI curves and returns the associated matplotlib axes object. This function is used in ``draw_daily_ghi`` and ``preplot_live_ghi_curves`` to create simple graphs of GHI curves (clearsky, measured, predicted). """ assert clearsky_ghi.ndim == 1 and station_ghi.ndim == 1 and clearsky_ghi.size == station_ghi.size assert pred_ghi is None or (pred_ghi.ndim == 1 and clearsky_ghi.size == pred_ghi.size) hour_tick_locator = matplotlib.dates.HourLocator(interval=4) minute_tick_locator = matplotlib.dates.HourLocator(interval=1) datetime_fmt = matplotlib.dates.DateFormatter("%H:%M") datetime_range = pd.date_range(window_start, window_end, freq=sample_step) xrange_real = matplotlib.dates.date2num( [d.to_pydatetime() for d in datetime_range]) if current_time is not None: ax.axvline(x=matplotlib.dates.date2num(current_time), color="r", label="current") station_name = f"measured ({station_name})" if station_name else "measured" ax.plot(xrange_real, clearsky_ghi, ":", label="clearsky") if station_color is not None: ax.plot(xrange_real, station_ghi, linestyle="solid", color=station_color, label=station_name) else: ax.plot(xrange_real, station_ghi, linestyle="solid", label=station_name) datetime_range = pd.date_range(window_start + horiz_offset, window_end + horiz_offset, freq=sample_step) xrange_offset = matplotlib.dates.date2num( [d.to_pydatetime() for d in datetime_range]) if pred_ghi is not None: ax.plot(xrange_offset, pred_ghi, ".-", label="predicted") ax.xaxis.set_major_locator(hour_tick_locator) ax.xaxis.set_major_formatter(datetime_fmt) ax.xaxis.set_minor_locator(minute_tick_locator) hour_offset = datetime.timedelta(hours=1) // sample_step ax.set_xlim(xrange_real[hour_offset - 1], xrange_real[-hour_offset + 1]) ax.format_xdata = matplotlib.dates.DateFormatter("%Y-%m-%d %H:%M") ax.grid(True) return ax
def plot_eeg_fft(data, ax: plt.Axes, fs: int = 256): N = data.shape[0] yf = fft(data) xf = fftfreq(N, 1 / fs)[:N // 2] ax.plot(xf, abs(yf[:N // 2])) ax.grid() pass
def plot_index(self, period: int, n: int, ax: plt.Axes = None): plot_data = self.featured_data(period, n) * 100 if ax is None: _, ax = plt.subplots(1, 1) plot_data.plot(ax=ax) ax.set_xlim(left=plot_data.index[0], right=plot_data.index[-1]) ax.grid(True) ax.yaxis.set_major_formatter(mtick.PercentFormatter()) return ax
def add_grid(ax: plt.Axes, is_grid: bool): # pylint: disable=invalid-name """ Add/remove grid to figure. :param ax: Figure axes. :type ax: matplotlib.pyplot.Axes :param is_grid: Add or remote grid to plot :type is_grid: bool """ ax.grid(is_grid)
def measureTau(abf: pyabf.ABF, sweep: int, epoch: int = 3, percentile: float = .05, ax: plt.Axes = None): abf.setSweep(sweep) # use epoch table to determine puff times puffTimeStart = abf.sweepEpochs.p1s[epoch] / abf.sampleRate puffTimeEnd = abf.sweepEpochs.p2s[epoch] / abf.sampleRate # calculate baseline level baselineStart = puffTimeStart - .1 baselineEnd = puffTimeStart baselineMean = getMean(abf, baselineStart, baselineEnd) # find antipeak antipeakIndex = getAntiPeakIndex(abf.sweepY, abf.sampleRate, puffTimeStart, puffTimeStart + .5) antipeakLevel = abf.sweepY[antipeakIndex] # find portion of curve to fit curveIndex1, curveIndex2 = getCurveIndexes(abf.sweepY, antipeakIndex, baselineMean, percentile) curveYs = -abf.sweepY[curveIndex1:curveIndex2] curveXs = np.arange(len(curveYs)) / abf.sampleRate try: p0 = (500, 15, 0) # start with values near those we expect params, cv = scipy.optimize.curve_fit(monoExp, curveXs, curveYs, p0) except: print(f"FIT FAILED (sweep {sweep})") return None m, t, b = params curveYsIdeal = monoExp(curveXs, m, t, b) tauMS = 1000 / t if (tauMS < 0): return None if ax: yPad = abs(antipeakLevel - baselineMean) * .1 ax.plot(abf.sweepX, abf.sweepY, alpha=.5) ax.grid(alpha=.5, ls='--') ax.axhline(baselineMean, ls='--', color='k') ax.plot(abf.sweepX[curveIndex1:curveIndex2], -curveYsIdeal, color='k') ax.set(title=f"first sweep tau = {tauMS:.02f} ms") ax.axis([ baselineStart - .1, baselineStart + 1, antipeakLevel - yPad, baselineMean + yPad ]) ax.axvspan(puffTimeEnd, puffTimeEnd + .5, color='g', alpha=.1) ax.axvspan(puffTimeEnd + .5, puffTimeEnd + .6, color='m', alpha=.1) return tauMS
def _plot_deviation(self, item: str, ax: plt.Axes = None, show: bool = True): """Helper function: Plot the sag in Cartesian coordinates. Parameters ---------- item : {'gantry', 'epid', 'collimator', 'couch'} The axis to plot. ax : None, matplotlib.Axes The axis to plot to. If None, creates a new plot. show : bool Whether to show the image. """ title = 'Relative {} displacement'.format(item) if item == EPID: attr = 'epid' item = GANTRY else: attr = 'bb' # get axis images, angles, and shifts imgs = [ image for image in self.images if image.variable_axis in (item, REFERENCE) ] angles = [ getattr(image, '{}_angle'.format(item.lower())) for image in imgs ] z_sag = np.array( [getattr(image, attr + '_z_offset') for image in imgs]) y_sag = np.array( [getattr(image, attr + '_y_offset') for image in imgs]) x_sag = np.array( [getattr(image, attr + '_x_offset') for image in imgs]) rms = np.sqrt(x_sag**2 + y_sag**2 + z_sag**2) # plot the axis deviation if ax is None: ax = plt.subplot(111) ax.plot(angles, z_sag, 'bo', label='In/Out', ls='-.') ax.plot(angles, x_sag, 'm^', label='Left/Right', ls='-.') if item not in (COUCH, COLLIMATOR): ax.plot(angles, y_sag, 'r*', label='Up/Down', ls='-.') ax.plot(angles, rms, 'g+', label='RMS', ls='-') ax.set_title(title) ax.set_ylabel('mm') ax.set_xlabel("{} angle".format(item)) ax.set_xticks(np.arange(0, 361, 45)) ax.set_xlim([-15, 375]) ax.grid(True) ax.legend(numpoints=1) if show: plt.show()
def _axis_formatting(ax: plt.Axes, xlen: int, ylen: int) -> None: """Construct figure and set sensible defaults.""" # Axes limits ax.set_xlim(0, xlen) ax.set_ylim(0, ylen) # Make ticks centred in each cell _set_ticks(xlen, ax.xaxis) _set_ticks(ylen, ax.yaxis) # Draw grid along minor ticks, then remove those ticks so they don't protrude ax.grid(which="minor", color="k") ax.tick_params(which="minor", length=0, width=0)
def plot_text(axes: plt.Axes, text: str): """Plot text on an axes Args: axes (plt.Axes): an axes object text (str): the text """ axes.axis('off') axes.grid('off') axes.text(x=0, y=0, s=text, horizontalalignment='left', fontdict=FONT)
def attach_electric_potential_plot_to_axis( self, axis: plt.Axes, show_electric_field: bool = True, show_vector_potential: bool = True, time_unit: u.Unit = "asec", legend_kwargs: Optional[dict] = None, show_y_label: bool = False, ): time_unit_value, time_unit_latex = u.get_unit_value_and_latex( time_unit) if legend_kwargs is None: legend_kwargs = dict() legend_defaults = dict(loc="lower left", fontsize=10, fancybox=True, framealpha=0.3) legend_kwargs = {**legend_defaults, **legend_kwargs} if show_electric_field: axis.plot( self.sim.data_times / time_unit_value, self.sim.data.electric_field_amplitude / u.atomic_electric_field, color=vis.COLOR_EFIELD, linewidth=1.5, label=fr"$ {vis.LATEX_EFIELD}(t) $", ) if show_vector_potential: axis.plot( self.sim.data_times / time_unit_value, u.proton_charge * self.sim.data.vector_potential_amplitude / u.atomic_momentum, color=vis.COLOR_AFIELD, linewidth=1.5, label=fr"$ e \, {vis.LATEX_AFIELD}(t) $", ) if show_y_label: axis.set_ylabel(rf"${vis.LATEX_EFIELD}(t)$", fontsize=13, color=vis.COLOR_EFIELD) axis.set_xlabel(rf"Time $t$ (${time_unit_latex}$)", fontsize=13) axis.tick_params(labelright=True) axis.set_xlim(self.sim.times[0] / time_unit_value, self.sim.times[-1] / time_unit_value) axis.legend(**legend_kwargs) axis.grid(True, **si.vis.DEFAULT_GRID_KWARGS)
def draw_trajectory_axis(env_axes: typing.Tuple[typing.Tuple, typing.Tuple], ax: plt.Axes, legend: bool = True, grid: bool = True): # Set axes limitations for x- and y-axis and add legend and grid to visualization. ax.set_xlim(*env_axes[0]) ax.set_ylim(*env_axes[1]) if grid: ax.grid() if legend: ax.legend() return ax
def plot_sir_model(ax: plt.Axes, model: "SIRModel", include_susceptible=True) -> plt.Axes: ax.margins(0) xs = model.x_obs ys = model.observe() y_min = 0, if (include_susceptible): y_max = np.ceil(model.population_size / 1000) * 1000 else: y_max = max([max(y[1:]) for y in ys]) mag = np.floor(np.log10(y_max)) y_max = (10**mag) * np.ceil(y_max / (10**mag)) x_min = min(xs, key=lambda x: x[0])[0] x_max = max(xs, key=lambda x: x[0])[0] # S if (include_susceptible): i = 0 y_obs = [y[i] for y in ys] ax.scatter(xs, y_obs, c="green", label="Susceptible") # I i = 1 y_obs = [y[i] for y in ys] ax.scatter(xs, y_obs, c="blue", label="Infectious") # R i = 2 y_obs = [y[i] for y in ys] ax.scatter(xs, y_obs, c="red", label="Removed") ax.set_title("Realisation of Population Sizes for Standard SIR Model", fontsize=20) ax.set_xlabel("Time-Period", fontsize=16) ax.set_ylabel("Population Size", fontsize=16) ax.set_xticks(list(range(x_min, x_max, 7)) + [x_max]) ax.set_yticks(np.linspace(0, y_max, 5)) ax.set_yticklabels(["{:,.0f}".format(x) for x in np.linspace(0, y_max, 5)]) ax.legend() ax.grid() return
def _plot_deviation(self, item: str, ax: plt.Axes = None, show: bool = True): """Helper function: Plot the sag in Cartesian coordinates. Parameters ---------- item : {'gantry', 'epid', 'collimator', 'couch'} The axis to plot. ax : None, matplotlib.Axes The axis to plot to. If None, creates a new plot. show : bool Whether to show the image. """ title = f'In-plane {item} displacement' if item == EPID: attr = 'cax2epid_vector' item = GANTRY else: attr = 'cax2bb_vector' # get axis images, angles, and shifts imgs = [ image for image in self.images if image.variable_axis in (item, REFERENCE) ] angles = [ getattr(image, '{}_angle'.format(item.lower())) for image in imgs ] xz_sag = np.array([getattr(img, attr).x for img in imgs]) y_sag = np.array([getattr(img, attr).y for img in imgs]) rms = np.sqrt(xz_sag**2 + y_sag**2) # plot the axis deviation if ax is None: ax = plt.subplot(111) ax.plot(angles, y_sag, 'bo', label='Y-axis', ls='-.') ax.plot(angles, xz_sag, 'm^', label='X/Z-axis', ls='-.') ax.plot(angles, rms, 'g+', label='RMS', ls='-') ax.set_title(title) ax.set_ylabel('mm') ax.set_xlabel(f"{item} angle") ax.set_xticks(np.arange(0, 361, 45)) ax.set_xlim([-15, 375]) ax.grid(True) ax.legend(numpoints=1) if show: plt.show()
def _draw_axes(self, ax: plt.Axes): ax.grid(which='both') max_magn = 1.0 max_field = 2.0 stepy = np.abs(max_magn / 10) zero_yy = np.arange(-max_magn - stepy, max_magn + 2 * stepy, stepy) zero_yx = np.zeros((len(zero_yy), 1)) stepx = np.abs(max_field / 10) zero_xx = np.arange(-max_field - stepx, max_field + 2 * stepx, stepx) zero_xy = np.zeros((len(zero_xx), 1)) ax.plot(zero_yx, zero_yy, '--k', zero_xx, zero_xy, '--k') ax.set_ylim(np.min(zero_yy), np.max(zero_yy)) ax.set_xlim(np.min(zero_xx), np.max(zero_xx))
def style_twin_axes(self, ax1: plt.Axes, ax2: plt.Axes): """Apply styling to a twin axes Parameters ---------- ax1 : plt.Axes Primary matplolib axis ax2 : plt.Axes Twinx matplolib axis """ ax1.tick_params(axis="x", labelrotation=self.xticks_rotation) ax1.grid(axis="both", visible=True, zorder=0) ax2.grid(visible=False)
def animate_waveforms(ax: plt.Axes, t: np.array, sol: np.array): ''' animate waveforms over time :param ax: plt.axis :param t: (N) times :param sol: (N, 2) pendulum solution :return: list of line plots ''' lns = [] for i in range(len(sol)): ln = ax.plot(t[:i], sol[:i, 0], 'g') ln1 = ax.plot(t[:i], sol[:i, 1], 'b') lns.append([*ln, *ln1]) ax.legend(['position', 'rate']) ax.set_xlim(0, t.max()) ax.set_ylim(sol.min(), sol.max()) ax.grid() return lns
def plot_throughput(df: pd.DataFrame, ax: plt.Axes, grouping_columns: Tuple[str, ...], x_column: str, y_columns: List[str]) -> None: def outlier_mean(c: str): def f(g: pd.DataFrame) -> float: cutoff = 0.5 * g[c].max() return g[g[c] >= cutoff][c].mean() / 100000 return f def outlier_std(c: str): def f(g: pd.DataFrame): cutoff = 0.5 * g[c].max() return g[g[c] >= cutoff][c].std() / 100000 return f # Draw throughput. grouped = df.groupby(grouping_columns) for (name, group) in grouped: name = [name] if len(grouping_columns) == 1 else name label = ','.join(f'{f}={x}' for (f, x) in zip(grouping_columns, name)) by_acceptors = group.groupby(x_column) for c in y_columns: throughput = by_acceptors.apply(outlier_mean(c)).sort_index() std = by_acceptors.apply(outlier_std(c)).sort_index() line = ax.plot(throughput.index, throughput, '-', marker=next(MARKERS), label=f'{c} {label}', linewidth=1.5)[0] # Draw error bars. ax.fill_between(throughput.index, throughput - std, throughput + std, color=line.get_color(), alpha=0.3) ax.set_xlabel(x_column) ax.set_ylabel('Throughput\n(100,000 commands per second)') ax.legend(loc='center left', bbox_to_anchor=(1, 0.5)) ax.grid()
def _plot_deviation(self, item: str, ax: plt.Axes=None, show: bool=True): """Helper function: Plot the sag in Cartesian coordinates. Parameters ---------- item : {'gantry', 'epid', 'collimator', 'couch'} The axis to plot. ax : None, matplotlib.Axes The axis to plot to. If None, creates a new plot. show : bool Whether to show the image. """ title = f'Relative {item} displacement' if item == EPID: attr = 'epid' item = GANTRY else: attr = 'bb' # get axis images, angles, and shifts imgs = [image for image in self.images if image.variable_axis in (item, REFERENCE)] angles = [getattr(image, '{}_angle'.format(item.lower())) for image in imgs] z_sag = np.array([getattr(image, attr + '_z_offset') for image in imgs]) y_sag = np.array([getattr(image, attr + '_y_offset') for image in imgs]) x_sag = np.array([getattr(image, attr + '_x_offset') for image in imgs]) rms = np.sqrt(x_sag**2+y_sag**2+z_sag**2) # plot the axis deviation if ax is None: ax = plt.subplot(111) ax.plot(angles, z_sag, 'bo', label='In/Out', ls='-.') ax.plot(angles, x_sag, 'm^', label='Left/Right', ls='-.') if item not in (COUCH, COLLIMATOR): ax.plot(angles, y_sag, 'r*', label='Up/Down', ls='-.') ax.plot(angles, rms, 'g+', label='RMS', ls='-') ax.set_title(title) ax.set_ylabel('mm') ax.set_xlabel(f"{item} angle") ax.set_xticks(np.arange(0, 361, 45)) ax.set_xlim([-15, 375]) ax.grid(True) ax.legend(numpoints=1) if show: plt.show()
def plot_im(ax: plt.Axes, image: torch.Tensor, true_class: str): """Plots given image on given axes. Sets title of image to true_class. Args: ax (plt.Axes): Axes on which to draw. image (torch.Tensor): Tensor image which has to be drawn on axes. true_class (str): Name of image class. """ image = un_normalize(image) image_cpu: np.ndarray = image.cpu().detach().numpy() im_max = np.max(image_cpu) im_min = np.min(image_cpu) image_cpu = (image_cpu - im_min) / (im_max - im_min) image_cpu = np.transpose(image_cpu, [1, 2, 0]) ax.set_title(true_class) ax.annotate(true_class, xy=(112, 112)) ax.grid(False) ax.set_axis_off() ax.imshow(image_cpu)
def _plot_analyzed_subimage(self, subimage: str, show: bool = True, ax: plt.Axes = None): """Plot an individual piece of the VMAT analysis. Parameters ---------- subimage : str Specifies which image to plot. show : bool Whether to actually plot the image. ax : matplotlib Axes, None If None (default), creates a new figure to plot to, otherwise plots to the given axes. """ plt.ioff() if ax is None: fig, ax = plt.subplots() # plot DMLC or OPEN image if subimage in (DMLC, OPEN): if subimage == DMLC: img = self.dmlc_image elif subimage == OPEN: img = self.open_image ax.imshow(img, cmap=get_dicom_cmap()) self._draw_segments(ax) plt.sca(ax) plt.axis('off') plt.tight_layout() # plot profile elif subimage == PROFILE: dmlc_prof, open_prof = self._median_profiles( (self.dmlc_image, self.open_image)) ax.plot(dmlc_prof.values, label='DMLC') ax.plot(open_prof.values, label='Open') ax.autoscale(axis='x', tight=True) ax.legend(loc=8, fontsize='large') ax.grid() if show: plt.show()
def plot_lt(df: pd.DataFrame, ax: plt.Axes, title: str) -> None: def outlier_throughput(g: pd.DataFrame) -> float: cutoff = 0.5 * g['throughput'].max() return g[g['throughput'] >= cutoff]['throughput'].mean() / 100000 def outlier_throughput_std(g: pd.DataFrame) -> float: cutoff = 0.5 * g['throughput'].max() return g[g['throughput'] >= cutoff]['throughput'].std() / 100000 # Draw throughput. grouped = df.groupby([ 'num_shards', 'num_replicas', 'num_proxy_replicas', 'server_options.push_size', 'server_options.push_period', 'aggregator_options.num_shard_cuts_per_proposal', 'replica_options.unsafe_yolo_execution' ]) for (name, group) in grouped: print(f'## {name}') print(group[['throughput', 'latency']]) by_clients = group.groupby('num_clients') throughput = by_clients['throughput'].agg(np.mean).sort_index() / 1000 throughput_std = by_clients['throughput'].agg( np.std).sort_index() / 1000 latency = by_clients['latency'].agg(np.mean).sort_index() line = ax.plot(throughput, latency, '-', marker=next(MARKERS), label=name, linewidth=2)[0] ax.fill_betweenx(latency, throughput - throughput_std, throughput + throughput_std, color=line.get_color(), alpha=0.25) ax.grid() ax.set_title(title) ax.set_xlabel('Throughput (100,000 commands per second)') ax.set_ylabel('Latency\n(milliseconds)') ax.legend(loc='center left', bbox_to_anchor=(1, 0.5))
def _plot_analyzed_subimage(self, subimage: str, show: bool=True, ax: plt.Axes=None): """Plot an individual piece of the VMAT analysis. Parameters ---------- subimage : str Specifies which image to plot. show : bool Whether to actually plot the image. ax : matplotlib Axes, None If None (default), creates a new figure to plot to, otherwise plots to the given axes. """ plt.ioff() if ax is None: fig, ax = plt.subplots() # plot DMLC or OPEN image if subimage in (DMLC, OPEN): if subimage == DMLC: img = self.dmlc_image elif subimage == OPEN: img = self.open_image ax.imshow(img, cmap=get_dicom_cmap()) self._draw_segments(ax) plt.sca(ax) plt.axis('off') plt.tight_layout() # plot profile elif subimage == PROFILE: dmlc_prof, open_prof = self._median_profiles((self.dmlc_image, self.open_image)) ax.plot(dmlc_prof.values, label='DMLC') ax.plot(open_prof.values, label='Open') ax.autoscale(axis='x', tight=True) ax.legend(loc=8, fontsize='large') ax.grid() if show: plt.show()
def plot_rhythm_grid(axes: plt.Axes, rhythm: Rhythm, unit: Unit, axis='x'): # TODO fix axis option duration = rhythm.get_duration(unit, ceil=True) measure_duration = rhythm.get_measure_duration(unit) beat_duration = rhythm.get_beat_duration(unit) measure_grid_ticks = np.arange(0, duration + 1, measure_duration) beat_grid_ticks = np.arange(0, duration + 1, beat_duration) if len(axis) > 2: raise ValueError("Illegal axis: %s" % axis) axes.set_xticks(measure_grid_ticks) axes.set_xticks(beat_grid_ticks, minor=True) axes.set_yticks(measure_grid_ticks) axes.set_yticks(beat_grid_ticks, minor=True) axes.set_axisbelow(True) axes.grid(which='minor', alpha=0.2, axis=axis) axes.grid(which='major', alpha=0.5, axis=axis)
def style_primary_axis( self, ax: plt.Axes, data_index: Optional[List[int]] = None, tick_labels: Optional[List[str]] = None, ): """Apply styling to a primary axis. Parameters ---------- ax : plt.Axes A matplolib axis """ ax.yaxis.set_label_position("right") ax.grid(axis="both", visible=True, zorder=0) if (all([data_index, tick_labels]) and isinstance(data_index, list) and isinstance(tick_labels, list)): ax.xaxis.set_major_formatter( ticker.FuncFormatter(lambda value, _: tick_labels[int(value)] if int(value) in data_index else "")) ax.xaxis.set_major_locator(ticker.MaxNLocator(6, integer=True)) ax.tick_params(axis="x", labelrotation=self.xticks_rotation)
def plot_lt(df: pd.DataFrame, ax: plt.Axes, title: str) -> None: def outlier_throughput(g: pd.DataFrame) -> float: cutoff = 0.5 * g['throughput'].max() return g[g['throughput'] >= cutoff]['throughput'].mean() / 100000 def outlier_throughput_std(g: pd.DataFrame) -> float: cutoff = 0.5 * g['throughput'].max() return g[g['throughput'] >= cutoff]['throughput'].std() / 100000 grouped = df.groupby([ 'num_replicas', 'num_proxy_leaders', 'num_acceptor_groups', 'num_acceptors_per_group', 'workload.write_size_mean', 'leader_options.flush_phase2as_every_n' ]) for (name, group) in grouped: print(f'## {name}') print(group[['throughput', 'latency']]) by_clients = group.groupby('num_clients') throughput = by_clients['throughput'].agg(np.mean).sort_index() / 1000 throughput_std = by_clients['throughput'].agg(np.std).sort_index() / 1000 latency = by_clients['latency'].agg(np.mean).sort_index() line = ax.plot(throughput, latency, '-', marker=next(MARKERS), label=name, linewidth=2)[0] ax.fill_betweenx(latency, throughput - throughput_std, throughput + throughput_std, color = line.get_color(), alpha=0.25) ax.set_title(title) ax.set_xlabel('Throughput (100,000 commands per second)') ax.set_ylabel('Latency\n(milliseconds)') ax.legend(loc='center left', bbox_to_anchor=(1, 0.5)) ax.grid(b=True)
def plot_word_frequency_vs_rank(text, axes: plt.Axes = None, label=None, title=None, annotate=True, as_probability=False): vs_rank = word_frequency_vs_rank rank, frequency = vs_rank(text, as_probability=as_probability) new_figure_created = False if axes is None: new_figure_created = True figure = plt.figure(figsize=(12, 8)) axes = figure.gca() axes.scatter(rank, frequency, label=label) axes.set_yscale('log') axes.set_xscale('log') axes.grid() if annotate: axes.set_xlabel('Word rank') if as_probability: y_label = 'Probability of occurrence' else: y_label = 'Frequency of occurrence' axes.set_ylabel(y_label) if title is not None: axes.set_title(title) if new_figure_created: format_figure(figure) return axes
def set_axes(xvalues: list, ax: plt.Axes = None, title: str = '', xlabel: str = '', ylabel: str = '', percentage=False, hidegrid=False): if ax is None: ax = plt.gca() if hidegrid: ax.grid(False) ax.set_title(title) ax.set_xlabel(xlabel) ax.set_ylabel(ylabel) if percentage: ax.set_ylim(0.0, 1.0) ax.set_xlabel(xlabel) ax.set_ylabel(ylabel) ax.set_xticklabels(xvalues, fontsize='small', ha='center', rotation=90) return ax