Docs/improve perf graphs (AntaresSimulatorTeam#1015)

Improve and change performance graph layout for more clarity. The code
is also updated to be able to ealisy select the Xpansion versions we
want to plot in the graph.

Author: tbittar

docs/user-guide/performance-history/perf-graphs.ipynb

@@ -96,9 +96,9 @@
                 {
                     "version": 1.4,
                     "batch_size": 96,
-                    "antares": 360,
-                    "problem_generation": 345,
-                    "benders": 957
+                    "antares": 390,
+                    "problem_generation": 344,
+                    "benders": 961
                 }
             ]
         },
@@ -147,9 +147,9 @@
                 {
                     "version": 1.4,
                     "batch_size": 96,
-                    "antares": 384,
-                    "problem_generation": 350,
-                    "benders": 1107
+                    "antares": 333,
+                    "problem_generation": 362,
+                    "benders": 972
                 }
             ]
         },

docs/user-guide/performance-history/perf_data.json

@@ -1,10 +1,11 @@
-from typing import List
-
 import json
+from typing import List, Optional
+
 import pandas as pd
-from matplotlib.figure import Figure
+from matplotlib import pyplot as plt
+from matplotlib import rc, rcParams, style
 from matplotlib.axes import Axes
-from matplotlib import pyplot as plt, rc, rcParams, style
+from matplotlib.figure import Figure
 
 ANTARES_STEP = "antares"
 PROBLEM_GENERATION_STEP = "problem_generation"
@@ -56,13 +57,15 @@ def stylize_data_for_display(self):
             "resolution.stopping_criterion.type",
             "resolution.stopping_criterion.value",
         ]
-        stylized_data = self.processed_data.loc[(slice(None), 1.0), columns_to_display]
+        stylized_data = self.processed_data.loc[(slice(None), 1.1), columns_to_display]
         stylized_data.index = stylized_data.index.droplevel(1)
         return stylized_data
 
 
 class PerfPlotsGenerator:
-    def __init__(self, perf_data: pd.DataFrame) -> None:
+    def __init__(
+        self, perf_data: pd.DataFrame, xpansion_versions: Optional[List[int]] = None
+    ) -> None:
         self.perf_data = perf_data
 
         self.fig: Figure
@@ -72,69 +75,111 @@ def __init__(self, perf_data: pd.DataFrame) -> None:
         rc("font", **{"family": "serif"})
         rcParams.update({"font.size": 16})
 
-    def _xpansion_versions(self) -> List[float]:
-        return self.perf_data.index.unique(level="version").tolist()
+        self.xpansion_versions = self._xpansion_versions(xpansion_versions)
 
-    def _create_fig(self) -> None:
+    def _xpansion_versions(self, xpansion_versions: Optional[List[str]]) -> List[float]:
+        valid_versions = self.perf_data.index.unique(level="version").tolist()
+        if xpansion_versions is None:
+            # If no version is specified by the user, return all versions present in the data
+            return valid_versions
+        else:
+            return_versions = []
+            for version in xpansion_versions:
+                if version in valid_versions:
+                    return_versions.append(version)
+            return return_versions
 
-        nb_versions = len(self._xpansion_versions())
-        fig, ax = plt.subplots(
-            1, nb_versions, sharey=True, figsize=(5 * nb_versions, 8)
-        )
+    def _create_fig(self) -> None:
+        nb_versions = self._get_nb_versions()
+        fig, ax = plt.subplots(1, 1, figsize=(8, 3 * nb_versions))
 
         self.fig = fig
         self.ax = ax
+        self.ax.invert_yaxis()
+
+    def _get_nb_versions(self):
+        return len(self.xpansion_versions)
 
     def _display_names(self) -> List[str]:
         return self.perf_data.index.unique(level="display_name").tolist()
 
     def _beautify_fig(self) -> None:
-        self.fig.subplots_adjust(bottom=0.2)
-        self.fig.suptitle("Xpansion performance evolution")
-
-        self.fig.supylabel("Execution time (s)")
-        self.fig.supxlabel("Study id")
-        self.ax[-1].legend()
-
-        for axes in self.ax:
-            axes.set_xticks(self._display_names())
-            axes.set_xticklabels(self._display_names(), rotation=90)
+        self.ax.set_yticks(
+            list(range(len(self._display_names()))),
+            [study for study in self._display_names()],
+        )
+        self.ax.set_ylim(self.ax.get_ylim()[0], 1.5 * self.ax.get_ylim()[1])
+        self.ax.legend(loc="upper center", ncol=3, fontsize=12)
+        self.ax.set_title("Xpansion performance evolution")
 
+        self.ax.set_xlabel("Execution time (s)")
         self.fig.tight_layout()
 
-    def _plot_single_version(self, version_count: int, xpansion_version: float) -> None:
-        antares_step_times = self.perf_data.loc[
-            (slice(None), xpansion_version), ANTARES_STEP
-        ].values
-        problem_generation_step_times = self.perf_data.loc[
-            (slice(None), xpansion_version), PROBLEM_GENERATION_STEP
-        ].values
-        benders_step_times = self.perf_data.loc[
-            (slice(None), xpansion_version), BENDERS_STEP
-        ].values
-
-        self.ax[version_count].bar(
-            self._display_names(), antares_step_times, label=ANTARES_STEP
-        )
-        self.ax[version_count].bar(
-            self._display_names(),
-            problem_generation_step_times,
-            bottom=antares_step_times,
-            label=PROBLEM_GENERATION_STEP,
-        )
-        self.ax[version_count].bar(
-            self._display_names(),
-            benders_step_times,
-            bottom=problem_generation_step_times + antares_step_times,
-            label=BENDERS_STEP,
-        )
-        self.ax[version_count].set_title(f"Version {xpansion_version}")
+    def _plot_study_data(self) -> None:
+
+        nb_versions = self._get_nb_versions()
+        height = 0.8 / nb_versions  # Defines space between different study data
+        epsilon = 0.03  # Defines space between bars of the data for the different version of the same study
+        actual_height = (1 - epsilon) * height
+        alpha_decrease_rate = 0.2  # Defines transparency difference between bars of the data for the different version of the same study
+
+        for count, study in enumerate(self._display_names()):
+            for version_cnt, xpansion_version in enumerate(self.xpansion_versions):
+                antares_time = self.perf_data.loc[
+                    (study, xpansion_version), ANTARES_STEP
+                ]
+                pb_gen_time = self.perf_data.loc[
+                    (study, xpansion_version), PROBLEM_GENERATION_STEP
+                ]
+                benders_time = self.perf_data.loc[
+                    (study, xpansion_version), BENDERS_STEP
+                ]
+
+                y_pos = self._bar_y_position(nb_versions, height, count, version_cnt)
+
+                antares_line = self.ax.barh(
+                    y_pos,
+                    antares_time,
+                    height=actual_height,
+                    color="C0",
+                    align="edge",
+                    alpha=1 - alpha_decrease_rate * version_cnt,
+                )
+                pb_gen_line = self.ax.barh(
+                    y_pos,
+                    pb_gen_time,
+                    height=actual_height,
+                    left=antares_time,
+                    color="C1",
+                    align="edge",
+                    alpha=1 - alpha_decrease_rate * version_cnt,
+                )
+                benders_line = self.ax.barh(
+                    y_pos,
+                    benders_time,
+                    left=pb_gen_time + antares_time,
+                    height=actual_height,
+                    color="C2",
+                    align="edge",
+                    alpha=1 - alpha_decrease_rate * version_cnt,
+                )
+                self.ax.bar_label(
+                    benders_line,
+                    [f"v{xpansion_version}: {antares_time + pb_gen_time + benders_time}s"],
+                    label_type="edge",
+                    fontsize=12,
+                )
+                if version_cnt == 0 and count == 0:
+                    antares_line.set_label(ANTARES_STEP)
+                    pb_gen_line.set_label(PROBLEM_GENERATION_STEP)
+                    benders_line.set_label(BENDERS_STEP)
+
+    def _bar_y_position(
+        self, nb_versions: int, height: float, count: int, version_cnt: int
+    ):
+        return count + height * (version_cnt - nb_versions / 2)
 
     def run(self) -> None:
-
         self._create_fig()
-
-        for version_count, xpansion_version in enumerate(self._xpansion_versions()):
-            self._plot_single_version(version_count, xpansion_version)
-
+        self._plot_study_data()
         self._beautify_fig()