def plot_data_distribution(plot: plt, data, feature_extractor, num_classes=3, small_points=False): features = feature_extractor.predict(data) labels = np.concatenate([y for x, y in data], axis=0) if small_points: marker_data = 'x' marker_colour = ['k', 'k', 'k', 'k', 'k', 'k', 'k', 'k', 'k', 'k'] markersize = 3 alpha = 0.3 else: marker_data = 'x' marker_colour = [ 'tab:blue', 'tab:orange', 'tab:green', 'tab:red', 'tab:purple', 'tab:brown', 'tab:pink', 'tab:gray', 'tab:olive', 'tab:cyan' ] markersize = 3 alpha = 0.7 for class_id in range(num_classes): x_class = features[labels == class_id] plot.plot(x_class[:, 1], x_class[:, 0], marker_data, color=marker_colour[class_id], ms=markersize, alpha=alpha)
def save_chart_image(self, chart_data_dict: dict, mpl_plt: plt) -> Path: """ Save image in db, and return path to file in temp storage. :param chart_data_dict: dict :param mpl_plt: matplotlib.pyplot :return: Path """ # Get image data: image = BytesIO() mpl_plt.savefig(image, format='png', dpi=300) # dpi - 120 comes to 1920*1080, 80 - 1280*720 image.seek(0) # Return pointer to start of binary stream. # Save image in db with self.session_scope() as session: chart = session.query( self.Chart).filter_by(id=chart_data_dict['chart_id']).one() chart.image = image.read() session.commit() image.seek(0) # Save file to temp and pass back Path temp_image_path = Path( DataFolder.generate_rel_path(DataFolder.TEMP_DIR.value), f"{chart_data_dict['chart_name']}.png") temp_image_path.write_bytes(image.read()) return temp_image_path
def plotSignal(self, ax: plt, n: int, xpos: int, ypos: float, sig: str, sig_type: str) -> None: if sig_type == "NS1": color = "deepskyblue" shift = 3 elif sig_type == "NS2": color = "deepskyblue" shift = 4 elif sig_type == "NS3": color = "deepskyblue" shift = 4 elif sig_type == "CON1": color = "goldenrod" shift = 3 elif sig_type == "CON2": color = "goldenrod" shift = 4 elif sig_type == "CON3": color = "goldenrod" shift = 4 elif sig_type == "RAP": color = "violet" shift = 2 else: raise ValueError("Wrong sig_type:" + sig_type) color = "gray" ax.plot(self.xMl[n - shift: n + 1], self.yMl[n - shift: n + 1], color=color, linewidth=1) # ax.text(xpos - 30, ypos - 0.004, sig, fontsize=12, color=color, fontweight="bold") ax.text(xpos - 120, ypos - 0.03, sig_type, fontsize=6, color=color, fontweight="bold")
def closeShortPosition(self, ax: plt, n: int, xpos: int, ypos: float, sig_type: int) -> None: if self.plot is True: if sig_type == 0: marker = "*k" elif sig_type == 1: marker = "xk" else: raise ValueError("Wrong sig_type:" + sig_type) ax.plot([ xpos, ], [ ypos, ], marker, markersize=5) if ypos != self.short_start_price: color = "red" if ypos < self.short_start_price else "blue" x = self.xMl[self.short_start_pos] ax.plot([x, x + 0.001], [ self.short_start_price, 2 * self.short_start_price - ypos ], color=color, linewidth=1) # print("close at", "\tn:", n, "\txpos:", xpos, "\typos:", ypos, "\tslope:",self.slope_list[n], "\tnadir:", self.short_nadir_price) self.pnl += self.short_start_price - ypos self.update_stat_df(pos_type="short", close_price=ypos) self.initDailyParam(pos_type="short")
def save_chart_image(self, chart_data_dict: dict, mpl_plt: plt) -> Path: """ Save image in db, and return path to file in temp storage. :param chart_data_dict: dict :param mpl_plt: matplotlib.pyplot :return: Path """ # Get image data: image = BytesIO() mpl_plt.savefig(image, format='png', dpi=300) # dpi - 120 comes to 1920*1080, 80 - 1280*720 image.seek(0) # Return pointer to start of binary stream. # Save image in db with self._connection() as conn: cursor = conn.cursor() cursor.execute( """ UPDATE chart SET image=? WHERE id=?; """, (image.read(), chart_data_dict['chart_id'])) image.seek(0) conn.commit() conn.close() # Save file to temp and pass back Path temp_image_path = Path( DataFolder.generate_rel_path(DataFolder.TEMP_DIR.value), f"{chart_data_dict['chart_name']}.png") temp_image_path.write_bytes(image.read()) return temp_image_path
def capture_figure(metadata: ReportFigure, figure: pyplot): fig_rel_path = os.path.join('figures', f'{metadata.title}.png') fig_path = os.path.join(report_directory, fig_rel_path) figure.savefig(fig_path) metadata.img_path = fig_rel_path report.figures.append(metadata)
def matplot(self, plot: plt, win: str): """Draw matplot chart""" buffer = io.StringIO() plot.savefig(buffer, format='svg') buffer.seek(0) svg = buffer.read() buffer.close() return self.svg(svg=svg, win=win)
def plotSignal(self, ax: plt, n: int, xpos: int, ypos: float, sig: str, sig_type: str) -> None: if sig_type == "CON1": shift = 3 elif sig_type == "CON3": shift = 4 elif sig_type == "RAP": shift = 2 else: raise ValueError("Wrong sig_type:" + sig_type) ax.plot(self.xMl[n - shift: n + 1], self.yMl[n - shift: n + 1], color="gray",linewidth=1) ax.text(xpos - 120, ypos - 0.03, sig_type, fontsize=6, color="gray", fontweight="bold")
def closePosition(self, close_type: str, ax: plt, n: int, xpos: int, ypos: float, marker: str): start_price = self.long_start_price if close_type == "long" else self.short_start_price pos = self.long_start_pos if close_type == "long" else self.short_start_pos if self.plot is True: ax.plot([xpos, ], [ypos, ], marker, markersize=5) if ypos != start_price: color = "red" if ypos > start_price else "blue" x = self.xMl[pos] ax.plot([x, x + 0.0001], [start_price, ypos], color=color, linewidth =1) self.pnl += ypos - start_price self.update_stat_df(pos_type=close_type, close_price=ypos) self.initDailyParam(pos_type=close_type)
def plotSignal(self, ax: plt, n: int, xpos: int, ypos: float, sig: str, sig_type: str) -> None: shift = 3 if sig_type == "CON1" else 2 ax.plot(self.xMl[n - shift:n + 1], self.yMl[n - shift:n + 1], color="gray", linewidth=1) ax.text(xpos - 120, ypos - 0.03, sig_type, fontsize=6, color="gray", fontweight="bold")
def __init__( self, chart: MatPlotLibPlot, width: Optional[Decimal] = None, height: Optional[Decimal] = None, ): byte_buffer = io.BytesIO() chart.savefig(byte_buffer, format="png") byte_buffer.seek(0) super(Chart, self).__init__(image=PILImage.open(byte_buffer), width=width, height=height)
def plot(masking: "Masking", mplot: plt) -> plt: """ Plot layer wise density bar plot. :param masking: Masking instance :type masking: sparselearning.core.Masking :param mplot: matplotlib object :type mplot: pyplot :return: matplotlib plot :rtype: pyplot """ density_ll = _get_density_ll(masking) bin_ll = np.arange(len(density_ll)) + 1 width = 0.8 mplot.clf() mplot.bar(bin_ll, density_ll, width, color="b") # Gets too crowded when including layer names # layer_name_ll = list(masking.masks.keys()) # plt.xticks(bin_ll, layer_name_ll) mplot.ylabel("Density") mplot.xlabel("Layer Number") return mplot
def set_plt_rc(self, plot: plt) -> plt: """Takes a plot and applies a style as rc params""" ft_background = "#FFF1E5" ft_democrat_blue = "#0F56B5" ft_republican_red = "#EF4647" ft_pink = "#E95D8C" ft_darkred = "#7D062E" ft_darkblue = "#065296" ft_blue = "#2591CE" ft_lightblue = "#72D9E7" ft_greenish = "#A2BC5D" ft_maybe_grey = "#716962" ft_golden = "#B89E17" plot.rcParams['figure.facecolor'] = ft_background plot.rcParams['axes.facecolor'] = ft_background plot.rcParams['text.color'] = ft_maybe_grey plot.rcParams['xtick.color'] = ft_maybe_grey plot.rcParams['ytick.color'] = ft_maybe_grey plot.rcParams['axes.labelcolor'] = ft_maybe_grey #plot.rcParams["axes.grid.axis"] ="y" #plot.rcParams["axes.grid"] = True plot.rcParams['axes.spines.left'] = True plot.rcParams['axes.spines.right'] = False plot.rcParams['axes.spines.top'] = False plot.rcParams['axes.spines.bottom'] = True #plot.rcParams['figure.figsize'] = (20,12) #plot.rcParams['lines.linewidth'] = self.line_width #plot.rcParams['axes.titlesize'] = self.large_font #plot.rcParams['font.size'] = self.small_font #plot.rcParams['xtick.labelsize'] = self.small_font #plot.rcParams['ytick.labelsize'] = self.small_font #plot.rcParams['axes.labelsize'] = self.small_font #plot.rcParams['ytick.labelsize'] = self.small_font plot.rcParams['xtick.major.size'] = 10 plot.rcParams['xtick.major.pad'] = 10 plot.rcParams['ytick.major.size'] = 0 plot.rcParams['ytick.major.pad'] = 10 plot.rcParams['figure.constrained_layout.use'] = True plot.rc('axes', prop_cycle=(cycler.cycler('color', [ ft_darkblue, ft_blue, ft_lightblue, ft_pink, ft_darkred, ft_greenish ]))) return plot
def add_scatter_and_annotate(self, fig: plt, x_all: np.array, y_all: np.array, colour: str, idxs: np.array, annotate=False): x = x_all[idxs] y = y_all[idxs] ax = fig.scatter(x, y, c=colour, alpha=self.opacity, s=20) # Check if we want to annotate any of these with their gene IDs if self.values_to_label is not None: texts = [] labels = self.df[self.label_column].values[idxs] for i, name in enumerate(labels): if name in self.values_to_label: lbl_bg = self.values_colours.get(name) color = self.text_colours.get(name) texts.append( fig.text(x[i], y[i], name, color=color, fontsize=self.label_font_size, bbox=dict(fc=lbl_bg, alpha=1.0))) adjust_text(texts, force_text=2.0) # Check if the user wants these labeled if self.label_big_sig and annotate: # If they do have a limit on the number of ones we show (i.e. we don't want 10000 gene names...) max_values = -1 * self.max_labels if len(y) < self.max_labels: max_values = -1 * (len(y) - 1) most_sig_idxs = np.argpartition(y, max_values)[max_values:] labels = self.df[self.label_column].values[idxs][most_sig_idxs] x = x[most_sig_idxs] y = y[most_sig_idxs] # We only label the ones with the max log fc for i, name in enumerate(labels): fig.annotate(name, (x[i], y[i]), xytext=(0, 10), textcoords='offset points', ha='center', va='bottom', bbox=dict(boxstyle='round,pad=0.5', fc='white', alpha=0.2)) return ax
def export_plt(plot_obj: plt, filename: str, filepath: str) -> str: """ Exports single frames from pyplot object. :param plot_obj: pyplot object to store frame from. :param filename: Desired file name of the *.png. :param filepath: Desired file path to store the frame. :return: Full storage path of the new *.png file (with extension) """ sub_folder = filepath # os.path.join(ICAP_DIR, filepath) if not os.path.exists( sub_folder): # Creates folder if folder does not exist os.makedirs(sub_folder) full_path = os.path.join(sub_folder, filename + '.png') plot_obj.savefig(full_path) return full_path
def get_plot(plot_obj: plt, data: List[IContainer]) -> (Figure, Subplot): """Returns plt object""" # Data labeled_dict = {} for collection in data: if collection.label not in labeled_dict: labeled_dict[collection.label] = list() labeled_dict[collection.label].append(collection) fig, ax = plot_obj.subplots() # Set plot layout ax.title.set_text( "Expectation value for different noise models and molecule parameters" ) # Title "Eigen Energy depending on Noise Channel" ax.set_xlabel("Interatomic Distance [$\AA$]") # X axis label ax.set_ylabel("Energy (Hartree) [$a.u.$]") # Y axis label # Set plot points reference_key = None for key in labeled_dict.keys(): reference_key = key x = [collection.molecule_param for collection in labeled_dict[key]] y = [collection.measured_value for collection in labeled_dict[key]] e = [collection.measured_std for collection in labeled_dict[key]] ax.errorbar(x, y, yerr=e, linestyle='None', marker='^', label=key) # "STO-3G" x = [ collection.molecule_param for collection in labeled_dict[reference_key] ] f = [collection.fci_value for collection in labeled_dict[reference_key]] h = [collection.hf_value for collection in labeled_dict[reference_key]] ax.plot(x, f, 'o', label="fci energy") ax.plot(x, h, 'o', label="HF energy") ax.legend(loc=0) return fig, ax
def generate(self, plot: pyplot, data: Any) -> None: stages = {row[0]: True for row in data}.keys() compilers = {row[1]: True for row in data}.keys() parameters = {row[2]: True for row in data}.keys() matplotlib.rcParams.update({'figure.autolayout': True}) number_of_stages = len(stages) figure, axes_list = plot.subplots(1, number_of_stages) # Change the height to be three fourths that of the original height as # it becomes very narrow otherwise figure_width, figure_height = figure.get_size_inches() figure.set_size_inches(figure_width, figure_height * 0.75) colors = [ "#e6194B", "#3cb44b", "#4363d8", "#f58231", "#469990", "#800000", "#9A6324", "#000075" ] for i, stage in enumerate(stages): axes = axes_list[i] for j, parameter in enumerate(parameters): for k, compiler in enumerate(compilers): specific_data = [ [row[0], row[3], row[4]] for row in data if (row[1] == compiler and row[2] == parameter and row[0] == stage) ] yy = [row[2] for row in specific_data] axes.plot(range(1, len(yy) + 1), yy, marker='.', color=colors[j * 2 + k]) labels = [pow(2, i) for i in range(0, len(yy))] axes.xaxis.set_major_locator( ticker.FixedLocator(range(1, len(labels) + 1))) axes.set_xticklabels(labels=labels, fontsize=7) for tick in axes.yaxis.get_major_ticks(): tick.label.set_fontsize(7) axes.set_title(stage, fontsize=7) axes_list[0].set_ylabel("Throughput") figure.text(0.5, 0, "Number of Threads", ha="center") legend = [] for parameter in parameters: for compiler in compilers: if parameter == "": legend.append(compiler) else: legend.append(compiler + "-" + parameter) figure.suptitle("", fontsize=10) figure.legend(legend, bbox_to_anchor=(.5, 1), loc="upper center", fontsize=7, ncol=len(legend)) return figure
def render_bounding_box(comma_delimited_rect: str, plot: plt): """ Helper method to render bounding box around the detected word """ box_coordinates = comma_delimited_rect.strip().split(',') x = int(box_coordinates[0].strip()) y = int(box_coordinates[1].strip()) width = int(box_coordinates[2].strip()) height = int(box_coordinates[3].strip()) bottom_left = [x, y] bottom_right = [x + width, y] top_left = [x, y + height] top_right = [x + width, y + height] points = [bottom_left, top_left, top_right, bottom_right, bottom_left] polygon = plt.Polygon(points, fill=None, edgecolor='xkcd:rusty red', closed=False) plot.gca().add_line(polygon)
def scatter_plot(plot: plt, df: HogwartsDataDescriber, course1: str, course2: str): """ Scatter plot for 2 courses :param plot: matplotlib.axes._subplots.AxesSubplot :param df: HogwartsDataDescriber :param course1: course 1 name :param course2: course 2 name :return: None """ for house, color in zip(df.houses, df.colors): # choose course marks of students belonging to the house x = df[course1][df['Hogwarts House'] == house] y = df[course2][df['Hogwarts House'] == house] plot.scatter(x, y, color=color, alpha=0.5)
def plot_box(a:ndarray,b:ndarray,ax:pyplot=None,figsize=FIGSIZE,grid:bool=False, facecolor=None,edgecolor=None,alpha=0.15,label=None,zorder=None): # plot the box from intervals a and b ''' INPUTS a: 1x2 ndarray x-interval b: 1x2 ndarray y-interval ''' fig=None if ax is None: fig,ax = pyplot.subplots(figsize=figsize) if grid: ax.grid() ax.fill_between(x=[a[0],a[1]], y1=[b[0],b[0]], y2=[b[1],b[1]],facecolor=facecolor,edgecolor=edgecolor,alpha=alpha,label=label,zorder=zorder) return fig,ax
def interface(self, configurator: Config, plot: plt, tiers: Dict): """Draws image's size plot and captures the percent user value. :param Config configurator: :param plt plot: :param Dict tiers: :return: """ # Drawing plot. print('Drawing plot...') plot.draw() plot.pause(0.001) print('Results:') for tier, count in tiers.items(): print('* TIER {}%: {} images.'.format(tier, count)) # User interaction. executing = True while executing: selected = -1 while not (0 <= selected <= 100): try: selected = int( input( '> Enter a percent value (1 to 100) or enter 0 to finish: ' )) except ValueError: print('Please, enter a NUMBER between 0 and 100') if selected != 0: result_dir = '{}{}/'.format( configurator.get_work_path(), FOLDER_NAME_OUTPUT_RESULT.format(selected)) if not path.exists(result_dir): self.get_result(configurator, selected) else: print('Selected_{} already exist!'.format(selected)) else: executing = False
def save_chart_image(self, chart_data_dict: dict, mpl_plt: plt) -> Path: """ Save image, and return path to file in application storage. Save to app_data/classname/chart_data with same filename as chart_name and chart_data_file name. NB User copy stored elsewhere. :param chart_data_dict: dict :param mpl_plt: plt - matplotlib.pyplot object :return: Path """ class_id = chart_data_dict['class_id'] default_chart_name = chart_data_dict['chart_default_filename'] app_data_save_pathname = self.class_data_path.joinpath(class_id, 'chart_data', f"{default_chart_name}.png") Path.mkdir(app_data_save_pathname.parent, parents=True, exist_ok=True) # Save in app_data/class_data/class_id/chart_data with chart_default_filename mpl_plt.savefig(app_data_save_pathname, format='png', dpi=300) # dpi - 120 comes to 1920*1080, 80 - 1280*720 return app_data_save_pathname
def plot_choice(num: int, plot: plt, df1: pd.DataFrame) -> None: """ Function to re-draw the canvas :param num: int of the RadioButton selection :param plot: plt Matplotlib.pyplot instance :param df1: pd.DataFrame of the TSA data :return: None """ plot.clf() blue = "#327ff6" gray = "#bdb8b6" if num == 1: # Daily raw pax numbers fig, axis = plt.subplots() axis.plot(df1['Date'], df1['2020'], color=blue, linestyle='-', label="2020") axis.plot(df1['Date'], df1['2019'], color=gray, linestyle='-', label="2019") plot.legend() plot.xlabel('Date') plot.ylabel('Passengers') plot.title('TSA Passenger Daily Throughput 2019 and 2020') axis.get_yaxis().set_major_formatter(FuncFormatter(lambda x, p: format(int(x), ','))) plot_new_canvas(fig, root) elif num == 2: # Weekly raw pax numbers weekly_data = df1.resample('W-Mon', label='right', closed='right', on='Date').sum().reset_index().sort_values(by='Date') fig, axis = plt.subplots() axis.plot(weekly_data['Date'], weekly_data['2020'], color=blue, linestyle='-', label="2020") axis.plot(weekly_data['Date'], weekly_data['2019'], color=gray, linestyle='-', label="2019") axis.get_yaxis().set_major_formatter(FuncFormatter(lambda x, p: format(int(x), ','))) plot.xlabel('Date') plot.ylabel('Passengers') plot.legend() plot.ylim(0, 20E6) plot.title('TSA Passenger Weekly Throughput 2019 and 2020') plot_new_canvas(fig, root) elif num == 3: # Daily YoY percentage fig, axis = plt.subplots() axis.plot(df1['Date'], df1['yoy'], color=blue, linestyle='-', label="2020") plot.legend() plot.xlabel('Date') plot.ylabel('Passenger Load Factor (%)') plot.title('TSA Passenger Daily Throughput in 2020 as a Percentage of 2019') plot_new_canvas(fig, root) elif num == 4: # Weekly YoY percentage weekly_data = df1.resample('W-Mon', label='right', closed='right', on='Date').sum().reset_index().sort_values(by='Date') weekly_data['yoy'] = (weekly_data['2020']/weekly_data['2019'])*100 fig, axis = plt.subplots() axis.plot(weekly_data['Date'], weekly_data['yoy'], color=blue, linestyle='-', label="2020") plot.xlabel('Date') plot.ylabel('Passenger Load Factor (%)') plot.legend() plot.title('TSA Passenger Daily Throughput in 2020 as a Percentage of 2019') plot_new_canvas(fig, root)
def generate(self, plot: pyplot, data: Any) -> None: # [("gcc", "ref", 184585549)] series: Dict[str, List[float]] = {} for row in data: label = " ".join(row[0:2]) if label not in series: series[label] = [] series[label].append(row[2]) values = list(series.values()) values.sort(key=lambda x: numpy.std(x), reverse=True) keys = list(series.keys()) keys.sort(key=lambda x: numpy.std(series[x]), reverse=True) plot.boxplot(values, showfliers=False) plot.gcf().axes[0].yaxis.get_major_formatter().set_scientific(False) plot.gcf().axes[0].set_xticklabels(keys) plot.title("") plot.ylabel(self.options.event) plot.xlabel("Optimizations")
def generate(self, plot: pyplot, data: Any) -> None: # [('low-end-laptop', 0, 'mceliece', '6960119f', 'clang', 'ref-optimized', 'keypair', 666.1022, 999, 665165462)] # clang, ref-optimized: [1, 2, 3, ...] series: Dict[str, Dict[int, float]] = {} # run_index: average duration baseline_average_durations: Dict[int, int] = {} # label: run_index: iteration: duration sum_per_label: Dict[str, Dict[int, Dict[int, int]]] = {} # Find values for row in data: compiler = row[4] features = row[5] run_index = row[1] if compiler == "gcc" and features == "ref": average_duration = row[7] baseline_average_durations[run_index] = average_duration else: label = "{} {}".format(compiler, features) if label not in sum_per_label: sum_per_label[label] = {} if run_index not in sum_per_label[label]: sum_per_label[label][run_index] = {} iteration = row[8] duration = row[9] sum_per_label[label][run_index][iteration] = duration baseline_avarage_duration = sum(baseline_average_durations.values() ) / len(baseline_average_durations) print("Baseline runs:", baseline_average_durations) print("Baseline average duration:", baseline_avarage_duration) for label in sum_per_label.keys(): max_length = max([ len(value.items()) for value in sum_per_label[label].values() ]) for i in range(max_length): relevant_items = [ items[i] for items in sum_per_label[label].values() if i in items ] duration = sum(relevant_items) / len(relevant_items) percentual_duration = (duration / 1e6) / baseline_avarage_duration if label not in series: series[label] = {} series[label][i] = (1 / percentual_duration - 1.0) colors = [ "#e6194B", "#3cb44b", "#4363d8", "#f58231", "#800000", "#9A6324", "#000075", "#469990" ] for i, key in enumerate(series.keys()): # TODO: may be wrong if there are gaps in data as it does not care about the acutal indexing values = series[key].values() plot.plot(values, label=key, color=colors[i]) plot.title("") plot.ylabel("Speedup") plot.xlabel("Iteration") plot.legend(bbox_to_anchor=(0.5, 1.05), loc="lower center", fontsize=8, ncol=len(series))
def save_plot(plot_to_save: plt, filename: str): plot_to_save.savefig(filename)
def show_plot(plot_to_show: plt): plot_to_show.show()
def plot3D(ax: plt, sub3d: plt, X: np.ndarray, y: np.ndarray, w: np.ndarray, name: str) -> None: ''' Visualize decision boundary and data classes in 3D :param ax: matplotlib :param sub3d: fig.add_subplot(XXX, projection='3d') :param X: data :param y: data labels :param w: model parameters :param name: plot name identifier :return: ''' x1 = np.array(X[1, :]) # note: X_train[0,:] is the added row of 1s (bias) x2 = np.array(X[2, :]) posterior1 = LOGREG().activationFunction(w, X) posterior1 = np.squeeze(np.asarray(posterior1)) markers = ['o', '+'] groundTruthLabels = np.unique(y) for li in range(len(groundTruthLabels)): x1_sub = x1[y[:] == groundTruthLabels[li]] x2_sub = x2[y[:] == groundTruthLabels[li]] m_sub = markers[li] posterior1_sub = posterior1[y[:] == groundTruthLabels[li]] sub3d.scatter(x1_sub, x2_sub, posterior1_sub, c=posterior1_sub, vmin=0, vmax=1, marker=m_sub, label='ground truth label = ' + str(li)) ax.legend() x = np.arange(x1.min(), x1.max(), 0.1) pms = [[0.1, 'k:'], [0.25, 'k--'], [0.5, 'r'], [0.75, 'k-.'], [0.9, 'k-']] for (p, m) in pms: yp = (-np.log((1 / p) - 1) - w[1] * x - w[0]) / w[2] yp = np.squeeze(np.asarray(yp)) z = np.ones(yp.shape) * p sub3d.plot(x, yp, z, m, label='p = ' + str(p)) ax.legend() ax.xlabel('feature 1') ax.ylabel('feature 2') ax.title(name + '\n Posterior for class labeled 1')
def _save_to_bytes_image(plot: plt): bytes_image = io.BytesIO() plot.savefig(bytes_image, format='png') bytes_image.seek(0) return bytes_image
def _save_to_png_image(plot: plt, filename): # write to disk isntead - this is used as alternative route for a different use case filedir = Path(__file__).parent relative_path = 'results' save_location = (filedir / relative_path / filename).resolve() plot.savefig(save_location, format='png')