pheval 0.4.7__py3-none-any.whl → 0.5.1__py3-none-any.whl

pheval/analyse/generate_plots.py

@@ -1,35 +1,32 @@
+from enum import Enum
 from pathlib import Path
-from typing import List
 
+import duckdb
 import matplotlib
-import numpy as np
-import pandas as pd
+import polars as pl
 import seaborn as sns
 from matplotlib import pyplot as plt
-from sklearn.metrics import auc, precision_recall_curve, roc_curve
+from sklearn.metrics import auc
 
-from pheval.analyse.benchmark_generator import (
-    BenchmarkRunOutputGenerator,
-    DiseaseBenchmarkRunOutputGenerator,
-    GeneBenchmarkRunOutputGenerator,
-    VariantBenchmarkRunOutputGenerator,
+from pheval.analyse.benchmark_db_manager import load_table_lazy
+from pheval.analyse.benchmark_output_type import (
+    BenchmarkOutputType,
+    BenchmarkOutputTypeEnum,
 )
-from pheval.analyse.benchmarking_data import BenchmarkRunResults
-from pheval.analyse.parse_benchmark_summary import parse_benchmark_db
-from pheval.analyse.run_data_parser import parse_run_config
-
+from pheval.analyse.run_data_parser import (
+    PlotCustomisation,
+    SinglePlotCustomisation,
+    parse_run_config,
+)
+from pheval.utils.logger import get_logger
 
-def trim_corpus_results_directory_suffix(corpus_results_directory: Path) -> Path:
-    """
-    Trim the suffix from the corpus results directory name.
+logger = get_logger()
 
-    Args:
-        corpus_results_directory (Path): The directory path containing corpus results.
 
-    Returns:
-        Path: The Path object with the suffix removed from the directory name.
-    """
-    return Path(str(corpus_results_directory).replace("_results", ""))
+class PlotTypes(Enum):
+    BAR_STACKED = "bar_stacked"
+    BAR_CUMULATIVE = "bar_cumulative"
+    BAR_NON_CUMULATIVE = "bar_non_cumulative"
 
 
 class PlotGenerator:
@@ -52,216 +49,132 @@ class PlotGenerator:
         """
         Initialise the PlotGenerator class.
         Note:
-            `self.stats` will be used to store statistics data.
-            `self.mrr` will store Mean Reciprocal Rank (MRR) values.
             Matplotlib settings are configured to remove the right and top axes spines
             for generated plots.
         """
         self.benchmark_name = benchmark_name
-        self.stats, self.mrr = [], []
         matplotlib.rcParams["axes.spines.right"] = False
         matplotlib.rcParams["axes.spines.top"] = False
 
     @staticmethod
-    def _create_run_identifier(results_dir: Path) -> str:
+    def _generate_stacked_data(benchmarking_stats_df: pl.DataFrame) -> pl.DataFrame:
         """
-        Create a run identifier from a path.
-
+        Generate stacked data.
         Args:
-            results_dir (Path): The directory path for results.
-
+            benchmarking_stats_df (pl.DataFrame): benchmarking stats dataframe.
         Returns:
-            str: A string representing the run identifier created from the given path.
+            pl.DataFrame: Data formatted for plotting stacked data.
         """
-        return f"{Path(results_dir).parents[0].name}_{trim_corpus_results_directory_suffix(Path(results_dir).name)}"
+        return benchmarking_stats_df.with_columns(
+            [
+                pl.col("run_identifier").alias("Run"),
+                pl.col("percentage@1").alias("Top"),
+                (pl.col("percentage@3") - pl.col("percentage@1")).alias("2-3"),
+                (pl.col("percentage@5") - pl.col("percentage@3")).alias("4-5"),
+                (pl.col("percentage@10") - pl.col("percentage@5")).alias("6-10"),
+                (pl.col("percentage_found") - pl.col("percentage@10")).alias(">10"),
+                (100 - pl.col("percentage_found")).alias("Missed"),
+            ]
+        ).select(["Run", "Top", "2-3", "4-5", "6-10", ">10", "Missed"])
 
-    def return_benchmark_name(self, benchmark_result: BenchmarkRunResults) -> str:
+    @staticmethod
+    def _extract_mrr_data(benchmarking_results_df: pl.DataFrame) -> pl.DataFrame:
         """
-        Return the benchmark name for a run.
+        Generate data in the correct format for dataframe creation for MRR (Mean Reciprocal Rank) bar plot.
 
         Args:
-            benchmark_result (BenchmarkRunResults): The benchmarking results for a run.
-
+            benchmarking_results_df (pl.DataFrame): benchmarking stats dataframe.
         Returns:
-            str: The benchmark name obtained from the given BenchmarkRunResults instance.
-        """
-        return (
-            benchmark_result.benchmark_name
-            if benchmark_result.results_dir is None
-            else self._create_run_identifier(benchmark_result.results_dir)
-        )
-
-    def _generate_stacked_bar_plot_data(self, benchmark_result: BenchmarkRunResults) -> None:
-        """
-        Generate data in the correct format for dataframe creation for a stacked bar plot,
-        appending to the self.stats attribute of the class.
-
-        Args:
-            benchmark_result (BenchmarkRunResults): The benchmarking results for a run.
+            pl.DataFrame: Data formatted for plotting MRR bar plot.
         """
-        rank_stats = benchmark_result.rank_stats
-        self.stats.append(
-            {
-                "Run": self.return_benchmark_name(benchmark_result),
-                "Top": benchmark_result.rank_stats.percentage_top(),
-                "2-3": rank_stats.percentage_difference(
-                    rank_stats.percentage_top3(), rank_stats.percentage_top()
-                ),
-                "4-5": rank_stats.percentage_difference(
-                    rank_stats.percentage_top5(), rank_stats.percentage_top3()
-                ),
-                "6-10": rank_stats.percentage_difference(
-                    rank_stats.percentage_top10(), rank_stats.percentage_top5()
-                ),
-                ">10": rank_stats.percentage_difference(
-                    rank_stats.percentage_found(), rank_stats.percentage_top10()
-                ),
-                "Missed": rank_stats.percentage_difference(100, rank_stats.percentage_found()),
-            }
+        return benchmarking_results_df.select(["run_identifier", "mrr"]).rename(
+            {"run_identifier": "Run", "mrr": "Percentage"}
         )
 
-    def _generate_stats_mrr_bar_plot_data(self, benchmark_result: BenchmarkRunResults) -> None:
+    def _save_fig(
+        self, benchmark_output_type: BenchmarkOutputType, y_lower_limit: int, y_upper_limit: int
+    ) -> None:
         """
-        Generate data in the correct format for dataframe creation for MRR (Mean Reciprocal Rank) bar plot,
-        appending to the self.mrr attribute of the class.
-
+        Save the generated figure.
         Args:
-            benchmark_result (BenchmarkRunResults): The benchmarking results for a run.
+            benchmark_output_type (BenchmarkOutputType): Benchmark output type.
+            y_lower_limit (int): Lower limit for the y-axis.
+            y_upper_limit (int): Upper limit for the y-axis.
         """
-        self.mrr.extend(
-            [
-                {
-                    "Rank": "MRR",
-                    "Percentage": benchmark_result.rank_stats.return_mean_reciprocal_rank(),
-                    "Run": self.return_benchmark_name(benchmark_result),
-                }
-            ]
+        plt.ylim(y_lower_limit, y_upper_limit)
+        plt.savefig(
+            f"{self.benchmark_name}_{benchmark_output_type.prioritisation_type_string}_rank_stats.svg",
+            format="svg",
+            bbox_inches="tight",
         )
 
     def generate_stacked_bar_plot(
         self,
-        benchmarking_results: List[BenchmarkRunResults],
-        benchmark_generator: BenchmarkRunOutputGenerator,
+        benchmarking_results_df: pl.DataFrame,
+        benchmark_output_type: BenchmarkOutputType,
+        plot_customisation: SinglePlotCustomisation,
     ) -> None:
         """
         Generate a stacked bar plot and Mean Reciprocal Rank (MRR) bar plot.
-
         Args:
-            benchmarking_results (List[BenchmarkRunResults]): List of benchmarking results for multiple runs.
-            benchmark_generator (BenchmarkRunOutputGenerator): Object containing benchmarking output generation details.
+            benchmarking_results_df (pl.DataFrame): benchmarking stats dataframe.
+            benchmark_output_type (BenchmarkOutputType): Benchmark output type.
+            plot_customisation (SinglePlotCustomisation): Plotting customisation.
         """
-        for benchmark_result in benchmarking_results:
-            self._generate_stacked_bar_plot_data(benchmark_result)
-            self._generate_stats_mrr_bar_plot_data(benchmark_result)
-        stats_df = pd.DataFrame(self.stats)
         plt.clf()
-        stats_df.set_index("Run").plot(
+        stats_df = self._generate_stacked_data(benchmarking_results_df)
+        stats_df.to_pandas().set_index("Run").plot(
             kind="bar",
             stacked=True,
             color=self.palette_hex_codes,
-            ylabel=benchmark_generator.y_label,
+            ylabel=benchmark_output_type.y_label,
             edgecolor="white",
         ).legend(loc="center left", bbox_to_anchor=(1.0, 0.5))
-        if benchmark_generator.plot_customisation.rank_plot_title is None:
-            plt.title(f"{benchmark_generator.prioritisation_type_string.capitalize()} Rank Stats")
-        else:
-            plt.title(
-                benchmark_generator.plot_customisation.rank_plot_title, loc="center", fontsize=15
-            )
-        plt.ylim(0, 100)
-        plt.savefig(
-            f"{self.benchmark_name}_{benchmark_generator.prioritisation_type_string}_rank_stats.svg",
-            format="svg",
-            bbox_inches="tight",
-        )
-
-        mrr_df = pd.DataFrame(self.mrr)
-        mrr_df.set_index("Run").plot(
+        plt.title(plot_customisation.rank_plot_title, loc="center", fontsize=15)
+        self._save_fig(benchmark_output_type, 0, 100)
+        mrr_df = self._extract_mrr_data(benchmarking_results_df)
+        mrr_df.to_pandas().set_index("Run").plot(
             kind="bar",
             color=self.palette_hex_codes,
-            ylabel=f"{benchmark_generator.prioritisation_type_string.capitalize()} mean reciprocal rank",
+            ylabel=f"{benchmark_output_type.prioritisation_type_string.capitalize()} mean reciprocal rank",
             legend=False,
             edgecolor="white",
         )
         plt.title(
-            f"{benchmark_generator.prioritisation_type_string.capitalize()} results - mean reciprocal rank"
-        )
-        plt.ylim(0, 1)
-        plt.savefig(
-            f"{self.benchmark_name}_{benchmark_generator.prioritisation_type_string}_mrr.svg",
-            format="svg",
-            bbox_inches="tight",
+            f"{benchmark_output_type.prioritisation_type_string.capitalize()} results - mean reciprocal rank"
         )
+        self._save_fig(benchmark_output_type, 0, 1)
 
-    def _generate_cumulative_bar_plot_data(self, benchmark_result: BenchmarkRunResults):
+    @staticmethod
+    def _generate_cumulative_bar_plot_data(benchmarking_results_df: pl.DataFrame) -> pl.DataFrame:
         """
         Generate data in the correct format for dataframe creation for a cumulative bar plot,
         appending to the self.stats attribute of the class.
-
-        Args:
-            benchmark_result (BenchmarkRunResults): The benchmarking results for a run.
         """
-        rank_stats = benchmark_result.rank_stats
-        run_identifier = self.return_benchmark_name(benchmark_result)
-        self.stats.extend(
+        return benchmarking_results_df.select(
             [
-                {
-                    "Rank": "Top",
-                    "Percentage": rank_stats.percentage_top() / 100,
-                    "Run": run_identifier,
-                },
-                {
-                    "Rank": "Top3",
-                    "Percentage": rank_stats.percentage_top3() / 100,
-                    "Run": run_identifier,
-                },
-                {
-                    "Rank": "Top5",
-                    "Percentage": rank_stats.percentage_top5() / 100,
-                    "Run": run_identifier,
-                },
-                {
-                    "Rank": "Top10",
-                    "Percentage": rank_stats.percentage_top10() / 100,
-                    "Run": run_identifier,
-                },
-                {
-                    "Rank": "Found",
-                    "Percentage": rank_stats.percentage_found() / 100,
-                    "Run": run_identifier,
-                },
-                {
-                    "Rank": "Missed",
-                    "Percentage": rank_stats.percentage_difference(
-                        100, rank_stats.percentage_found()
-                    )
-                    / 100,
-                    "Run": run_identifier,
-                },
-                {
-                    "Rank": "MRR",
-                    "Percentage": rank_stats.return_mean_reciprocal_rank(),
-                    "Run": run_identifier,
-                },
+                pl.col("run_identifier").alias("Run"),
+                pl.col("percentage@1").alias("Top") / 100,
+                pl.col("percentage@3").alias("Top3") / 100,
+                pl.col("percentage@5").alias("Top5") / 100,
+                pl.col("percentage@10").alias("Top10") / 100,
+                pl.col("percentage_found").alias("Found") / 100,
+                pl.col("mrr").alias("MRR"),
             ]
         )
 
-    def generate_cumulative_bar(
+    def _plot_bar_plot(
         self,
-        benchmarking_results: List[BenchmarkRunResults],
-        benchmark_generator: BenchmarkRunOutputGenerator,
+        benchmark_output_type: BenchmarkOutputType,
+        stats_df: pl.DataFrame,
+        plot_customisation: SinglePlotCustomisation,
     ) -> None:
-        """
-        Generate a cumulative bar plot.
-
-        Args:
-            benchmarking_results (List[BenchmarkRunResults]): List of benchmarking results for multiple runs.
-            benchmark_generator (BenchmarkRunOutputGenerator): Object containing benchmarking output generation details.
-        """
-        for benchmark_result in benchmarking_results:
-            self._generate_cumulative_bar_plot_data(benchmark_result)
-        stats_df = pd.DataFrame(self.stats)
-        plt.clf()
+        stats_df = stats_df.to_pandas().melt(
+            id_vars=["Run"],
+            value_vars=["Top", "Top3", "Top5", "Top10", "Found", "MRR"],
+            var_name="Rank",
+            value_name="Percentage",
+        )
         sns.catplot(
             data=stats_df,
             kind="bar",
@@ -271,132 +184,77 @@ class PlotGenerator:
             palette=self.palette_hex_codes,
             edgecolor="white",
             legend=False,
-        ).set(xlabel="Rank", ylabel=benchmark_generator.y_label)
+        ).set(xlabel="Rank", ylabel=benchmark_output_type.y_label)
         plt.legend(loc="upper center", bbox_to_anchor=(0.5, -0.15), ncol=3, title="Run")
-        if benchmark_generator.plot_customisation.rank_plot_title is None:
-            plt.title(
-                f"{benchmark_generator.prioritisation_type_string.capitalize()} Cumulative Rank Stats"
-            )
-        else:
-            plt.title(
-                benchmark_generator.plot_customisation.rank_plot_title, loc="center", fontsize=15
-            )
-        plt.ylim(0, 1)
-        plt.savefig(
-            f"{self.benchmark_name}_{benchmark_generator.prioritisation_type_string}_rank_stats.svg",
-            format="svg",
-            bbox_inches="tight",
-        )
+        plt.title(plot_customisation.rank_plot_title, loc="center", fontsize=15)
+        self._save_fig(benchmark_output_type, 0, 1)
 
     def _generate_non_cumulative_bar_plot_data(
-        self, benchmark_result: BenchmarkRunResults
-    ) -> [dict]:
+        self, benchmarking_results_df: pl.DataFrame
+    ) -> pl.DataFrame:
         """
         Generate data in the correct format for dataframe creation for a non-cumulative bar plot,
         appending to the self.stats attribute of the class.
-
-        Args:
-            benchmark_result (BenchmarkRunResults): The benchmarking results for a run.
         """
-        rank_stats = benchmark_result.rank_stats
-        run_identifier = self.return_benchmark_name(benchmark_result)
-        self.stats.extend(
-            [
-                {
-                    "Rank": "Top",
-                    "Percentage": rank_stats.percentage_top() / 100,
-                    "Run": run_identifier,
-                },
-                {
-                    "Rank": "2-3",
-                    "Percentage": rank_stats.percentage_difference(
-                        rank_stats.percentage_top3(), rank_stats.percentage_top()
-                    )
-                    / 100,
-                    "Run": run_identifier,
-                },
-                {
-                    "Rank": "4-5",
-                    "Percentage": rank_stats.percentage_difference(
-                        rank_stats.percentage_top5(), rank_stats.percentage_top3()
-                    )
-                    / 100,
-                    "Run": run_identifier,
-                },
-                {
-                    "Rank": "6-10",
-                    "Percentage": rank_stats.percentage_difference(
-                        rank_stats.percentage_top10(), rank_stats.percentage_top5()
-                    )
-                    / 100,
-                    "Run": run_identifier,
-                },
-                {
-                    "Rank": ">10",
-                    "Percentage": rank_stats.percentage_difference(
-                        rank_stats.percentage_found(), rank_stats.percentage_top10()
-                    )
-                    / 100,
-                    "Run": run_identifier,
-                },
-                {
-                    "Rank": "Missed",
-                    "Percentage": rank_stats.percentage_difference(
-                        100, rank_stats.percentage_found()
-                    )
-                    / 100,
-                    "Run": run_identifier,
-                },
-                {
-                    "Rank": "MRR",
-                    "Percentage": rank_stats.return_mean_reciprocal_rank(),
-                    "Run": run_identifier,
-                },
-            ]
+        return self._generate_stacked_data(benchmarking_results_df).hstack(
+            self._extract_mrr_data(benchmarking_results_df).select(
+                pl.col("Percentage").alias("MRR")
+            )
         )
 
+    def generate_cumulative_bar(
+        self,
+        benchmarking_results_df: pl.DataFrame,
+        benchmark_generator: BenchmarkOutputType,
+        plot_customisation: SinglePlotCustomisation,
+    ) -> None:
+        """
+        Generate a cumulative bar plot.
+        """
+        plt.clf()
+        stats_df = self._generate_cumulative_bar_plot_data(benchmarking_results_df)
+        self._plot_bar_plot(benchmark_generator, stats_df, plot_customisation)
+
+    def generate_non_cumulative_bar(
+        self,
+        benchmarking_results_df: pl.DataFrame,
+        benchmark_generator: BenchmarkOutputType,
+        plot_customisation: SinglePlotCustomisation,
+    ) -> None:
+        """
+        Generate a non-cumulative bar plot.
+        """
+        plt.clf()
+        stats_df = self._generate_non_cumulative_bar_plot_data(benchmarking_results_df)
+        self._plot_bar_plot(benchmark_generator, stats_df, plot_customisation)
+
     def generate_roc_curve(
         self,
-        benchmarking_results: List[BenchmarkRunResults],
-        benchmark_generator: BenchmarkRunOutputGenerator,
+        curves: pl.DataFrame,
+        benchmark_generator: BenchmarkOutputType,
+        plot_customisation: SinglePlotCustomisation,
     ):
         """
         Generate and plot Receiver Operating Characteristic (ROC) curves for binary classification benchmark results.
 
         Args:
-            benchmarking_results (List[BenchmarkRunResults]): List of benchmarking results for multiple runs.
-            benchmark_generator (BenchmarkRunOutputGenerator): Object containing benchmarking output generation details.
         """
         plt.clf()
-        for i, benchmark_result in enumerate(benchmarking_results):
-            y_score = np.array(benchmark_result.binary_classification_stats.scores)
-            y_score = np.nan_to_num(
-                y_score,
-                nan=0.0,
-                posinf=max(y_score[np.isfinite(y_score)]),
-                neginf=min(y_score[np.isfinite(y_score)]),
-            )
-            fpr, tpr, thresh = roc_curve(
-                benchmark_result.binary_classification_stats.labels,
-                y_score,
-                pos_label=1,
-            )
+        for i, row in enumerate(curves.iter_rows(named=True)):
+            run_identifier = row["run_identifier"]
+            fpr = row["fpr"]
+            tpr = row["tpr"]
             roc_auc = auc(fpr, tpr)
-
             plt.plot(
                 fpr,
                 tpr,
-                label=f"{self.return_benchmark_name(benchmark_result)} ROC Curve (AUC = {roc_auc:.2f})",
+                label=f"{run_identifier} ROC Curve (AUC = {roc_auc:.2f})",
                 color=self.palette_hex_codes[i],
             )
-
-        plt.plot(linestyle="--", color="gray")
+        plt.plot([0, 1], [0, 1], linestyle="--", color="gray")
         plt.xlabel("False Positive Rate")
         plt.ylabel("True Positive Rate")
-        if benchmark_generator.plot_customisation.roc_curve_title is None:
-            plt.title("Receiver Operating Characteristic (ROC) Curve")
-        else:
-            plt.title(benchmark_generator.plot_customisation.roc_curve_title)
+        plt.title(plot_customisation.roc_curve_title)
         plt.legend(loc="upper center", bbox_to_anchor=(0.5, -0.15))
         plt.savefig(
             f"{self.benchmark_name}_{benchmark_generator.prioritisation_type_string}_roc_curve.svg",
@@ -406,46 +264,30 @@ class PlotGenerator:
 
     def generate_precision_recall(
         self,
-        benchmarking_results: List[BenchmarkRunResults],
-        benchmark_generator: BenchmarkRunOutputGenerator,
+        curves: pl.DataFrame,
+        benchmark_generator: BenchmarkOutputType,
+        plot_customisation: SinglePlotCustomisation,
     ):
         """
         Generate and plot Precision-Recall curves for binary classification benchmark results.
-
-        Args:
-            benchmarking_results (List[BenchmarkRunResults]): List of benchmarking results for multiple runs.
-            benchmark_generator (BenchmarkRunOutputGenerator): Object containing benchmarking output generation details.
         """
         plt.clf()
         plt.figure()
-        for i, benchmark_result in enumerate(benchmarking_results):
-            y_score = np.array(benchmark_result.binary_classification_stats.scores)
-            y_score = np.nan_to_num(
-                y_score,
-                nan=0.0,
-                posinf=max(y_score[np.isfinite(y_score)]),
-                neginf=min(y_score[np.isfinite(y_score)]),
-            )
-            precision, recall, thresh = precision_recall_curve(
-                benchmark_result.binary_classification_stats.labels,
-                y_score,
-            )
-            precision_recall_auc = auc(recall, precision)
+        for i, row in enumerate(curves.iter_rows(named=True)):
+            run_identifier = row["run_identifier"]
+            precision = row["precision"]
+            recall = row["recall"]
+            pr_auc = auc(recall[::-1], precision[::-1])
             plt.plot(
                 recall,
                 precision,
-                label=f"{self.return_benchmark_name(benchmark_result)} Precision-Recall Curve "
-                f"(AUC = {precision_recall_auc:.2f})",
+                label=f"{run_identifier} Precision-Recall Curve (AUC = {pr_auc:.2f})",
                 color=self.palette_hex_codes[i],
             )
-
-        plt.plot(linestyle="--", color="gray")
+        plt.plot([0, 1], [0, 1], linestyle="--", color="gray")
         plt.xlabel("Recall")
         plt.ylabel("Precision")
-        if benchmark_generator.plot_customisation.precision_recall_title is None:
-            plt.title("Precision-Recall Curve")
-        else:
-            plt.title(benchmark_generator.plot_customisation.precision_recall_title)
+        plt.title(plot_customisation.precision_recall_title)
         plt.legend(loc="upper center", bbox_to_anchor=(0.5, -0.15))
         plt.savefig(
             f"{self.benchmark_name}_{benchmark_generator.prioritisation_type_string}_pr_curve.svg",
@@ -453,112 +295,85 @@ class PlotGenerator:
             bbox_inches="tight",
         )
 
-    def generate_non_cumulative_bar(
-        self,
-        benchmarking_results: List[BenchmarkRunResults],
-        benchmark_generator: BenchmarkRunOutputGenerator,
-    ) -> None:
-        """
-        Generate a non-cumulative bar plot.
-
-        Args:
-            benchmarking_results (List[BenchmarkRunResults]): List of benchmarking results for multiple runs.
-            benchmark_generator (BenchmarkRunOutputGenerator): Object containing benchmarking output generation details.
-        """
-        plt.clf()
-        for benchmark_result in benchmarking_results:
-            self._generate_non_cumulative_bar_plot_data(benchmark_result)
-
-        stats_df = pd.DataFrame(self.stats)
-        sns.catplot(
-            data=stats_df,
-            kind="bar",
-            x="Rank",
-            y="Percentage",
-            hue="Run",
-            palette=self.palette_hex_codes,
-            edgecolor="white",
-            legend=False,
-        ).set(xlabel="Rank", ylabel=benchmark_generator.y_label)
-        plt.legend(loc="upper center", bbox_to_anchor=(0.5, -0.15), ncol=3, title="Run")
-        if benchmark_generator.plot_customisation.rank_plot_title is None:
-            plt.title(
-                f"{benchmark_generator.prioritisation_type_string.capitalize()} Non-Cumulative Rank Stats"
-            )
-        else:
-            plt.title(
-                benchmark_generator.plot_customisation.rank_plot_title, loc="center", fontsize=15
-            )
-        plt.ylim(0, 1)
-        plt.savefig(
-            f"{self.benchmark_name}_{benchmark_generator.prioritisation_type_string}_rank_stats.svg",
-            format="svg",
-            bbox_inches="tight",
-        )
-
 
 def generate_plots(
     benchmark_name: str,
-    benchmarking_results: List[BenchmarkRunResults],
-    benchmark_generator: BenchmarkRunOutputGenerator,
-    generate_from_db: bool = False,
+    benchmarking_results_df: pl.DataFrame,
+    curves: pl.DataFrame,
+    benchmark_output_type: BenchmarkOutputType,
+    plot_customisation: PlotCustomisation,
 ) -> None:
     """
     Generate summary statistics bar plots for prioritisation.
 
     This method generates summary statistics bar plots based on the provided benchmarking results and plot type.
-
-    Args:
-        benchmarking_results (list[BenchmarkRunResults]): List of benchmarking results for multiple runs.
-        benchmark_generator (BenchmarkRunOutputGenerator): Object containing benchmarking output generation details.
-        generate_from_db (bool): Specify whether to generate plots from the db file. Defaults to False.
     """
     plot_generator = PlotGenerator(benchmark_name)
-    if not generate_from_db:
-        plot_generator.generate_roc_curve(benchmarking_results, benchmark_generator)
-        plot_generator.generate_precision_recall(benchmarking_results, benchmark_generator)
-    if benchmark_generator.plot_customisation.plot_type == "bar_stacked":
-        plot_generator.generate_stacked_bar_plot(benchmarking_results, benchmark_generator)
-    elif benchmark_generator.plot_customisation.plot_type == "bar_cumulative":
-        plot_generator.generate_cumulative_bar(benchmarking_results, benchmark_generator)
-    elif benchmark_generator.plot_customisation.plot_type == "bar_non_cumulative":
-        plot_generator.generate_non_cumulative_bar(benchmarking_results, benchmark_generator)
+    plot_customisation_type = getattr(
+        plot_customisation, f"{benchmark_output_type.prioritisation_type_string}_plots"
+    )
+    logger.info("Generating ROC curve visualisations.")
+    plot_generator.generate_roc_curve(curves, benchmark_output_type, plot_customisation_type)
+    logger.info("Generating Precision-Recall curves visualisations.")
+    plot_generator.generate_precision_recall(curves, benchmark_output_type, plot_customisation_type)
+    plot_type = PlotTypes(plot_customisation_type.plot_type)
+    match plot_type:
+        case PlotTypes.BAR_STACKED:
+            logger.info("Generating stacked bar plot.")
+            plot_generator.generate_stacked_bar_plot(
+                benchmarking_results_df, benchmark_output_type, plot_customisation_type
+            )
+        case PlotTypes.BAR_CUMULATIVE:
+            logger.info("Generating cumulative bar plot.")
+            plot_generator.generate_cumulative_bar(
+                benchmarking_results_df, benchmark_output_type, plot_customisation_type
+            )
+        case PlotTypes.BAR_NON_CUMULATIVE:
+            logger.info("Generating non cumulative bar plot.")
+            plot_generator.generate_non_cumulative_bar(
+                benchmarking_results_df, benchmark_output_type, plot_customisation_type
+            )
 
 
-def generate_plots_from_benchmark_summary_db(
-    benchmark_db: Path,
-    run_data: Path,
-):
+def generate_plots_from_db(db_path: Path, config: Path) -> None:
     """
-    Generate bar plot from summary benchmark results.
-
-    Reads a summary of benchmark results from a benchmark db and generates a bar plot
-    based on the analysis type and plot type.
-
+    Generate plots from database file.
     Args:
-        benchmark_db (Path): Path to the summary TSV file containing benchmark results.
-        run_data (Path): Path to YAML benchmarking configuration file.
+        db_path (Path): Path to the database file.
+        config (Path): Path to the benchmarking config file.
     """
-    benchmark_stats_summary = parse_benchmark_db(benchmark_db)
-    config = parse_run_config(run_data)
-    if benchmark_stats_summary.gene_results:
-        generate_plots(
-            config.benchmark_name,
-            benchmark_stats_summary.gene_results,
-            GeneBenchmarkRunOutputGenerator(config.plot_customisation.gene_plots),
-            True,
+    logger.info(f"Generating plots from {db_path}")
+    conn = duckdb.connect(db_path)
+    logger.info(f"Parsing configurations from {config}")
+    benchmark_config_file = parse_run_config(config)
+    tables = {
+        row[0]
+        for row in conn.execute(
+            """SELECT table_name FROM duckdb_tables WHERE table_name """
+            """LIKE '%_summary%' OR table_name LIKE '%_binary_classification_curves'"""
+        ).fetchall()
+    }
+    for benchmark_output_type in BenchmarkOutputTypeEnum:
+        summary_table = (
+            f"{benchmark_config_file.benchmark_name}_"
+            f"{benchmark_output_type.value.prioritisation_type_string}_summary"
         )
-    if benchmark_stats_summary.variant_results:
-        generate_plots(
-            config.benchmark_name,
-            benchmark_stats_summary.variant_results,
-            VariantBenchmarkRunOutputGenerator(config.plot_customisation.variant_plots),
-            True,
-        )
-    elif benchmark_stats_summary.disease_results:
-        generate_plots(
-            config.benchmark_name,
-            benchmark_stats_summary.disease_results,
-            DiseaseBenchmarkRunOutputGenerator(config.plot_customisation.disease_plots),
-            True,
+        curve_table = (
+            f"{benchmark_config_file.benchmark_name}_"
+            f"{benchmark_output_type.value.prioritisation_type_string}_binary_classification_curves"
         )
+        if summary_table in tables and curve_table in tables:
+            logger.info(
+                f"Generating plots for {benchmark_output_type.value.prioritisation_type_string} prioritisation."
+            )
+            benchmarking_results_df = load_table_lazy(summary_table, conn).collect()
+            curves_df = load_table_lazy(curve_table, conn).collect()
+            generate_plots(
+                benchmark_name=benchmark_config_file.benchmark_name,
+                benchmarking_results_df=benchmarking_results_df,
+                curves=curves_df,
+                benchmark_output_type=benchmark_output_type.value,
+                plot_customisation=benchmark_config_file.plot_customisation,
+            )
+    logger.info("Finished generating plots.")
+    conn.close()