halib 0.1.85__py3-none-any.whl → 0.1.87__py3-none-any.whl

halib/filetype/csvfile.py

@@ -9,6 +9,7 @@ from loguru import logger
 from itables import init_notebook_mode, show
 import pygwalker as pyg
 import textwrap
+import csv
 
 console = Console()
 
@@ -18,6 +19,34 @@ def read(file, separator=","):
     return df
 
 
+def read_auto_sep(filepath, sample_size=2048, **kwargs):
+    """
+    Read a CSV file with automatic delimiter detection.
+
+    Parameters
+    ----------
+    filepath : str
+        Path to the CSV file.
+    sample_size : int, optional
+        Number of bytes to read for delimiter sniffing.
+    **kwargs : dict
+        Extra keyword args passed to pandas.read_csv.
+
+    Returns
+    -------
+    df : pandas.DataFrame
+    """
+    with open(filepath, "r", newline="", encoding=kwargs.get("encoding", "utf-8")) as f:
+        sample = f.read(sample_size)
+        f.seek(0)
+        try:
+            dialect = csv.Sniffer().sniff(sample, delimiters=[",", ";", "\t", "|", ":"])
+            sep = dialect.delimiter
+        except csv.Error:
+            sep = ","  # fallback if detection fails
+
+    return pd.read_csv(filepath, sep=sep, **kwargs)
+
 # for append, mode = 'a'
 def fn_write(df, outfile, mode="w", header=True, index_label=None):
     if not outfile.endswith(".csv"):

halib/research/base_exp.py

@@ -82,6 +82,7 @@ class BaseExperiment(PerfCalc, ABC):
         """
         self.init_general(self.config.get_general_cfg())
         self.prepare_dataset(self.config.get_dataset_cfg())
+        self.prepare_metrics(self.config.get_metric_cfg())
 
         # Save config before running
         self.config.save_to_outdir()

halib/research/mics.py

@@ -0,0 +1,16 @@
+import platform
+
+PC_NAME_TO_ABBR = {
+    "DESKTOP-JQD9K01": "MainPC",
+    "DESKTOP-5IRHU87": "MSI_Laptop",
+    "DESKTOP-96HQCNO": "4090_SV",
+    "DESKTOP-Q2IKLC0": "4GPU_SV",
+    "DESKTOP-QNS3DNF": "1GPU_SV"
+}
+
+def get_PC_name():
+    return platform.node()
+
+def get_PC_abbr_name():
+    pc_name = get_PC_name()
+    return PC_NAME_TO_ABBR.get(pc_name, "Unknown")

halib/research/plot.py

@@ -1,300 +1,495 @@
+import os
+import pandas as pd
+import plotly.express as px
+from rich.console import Console
 from ..common import now_str, norm_str, ConsoleLog
 from ..filetype import csvfile
 from ..system import filesys as fs
-from functools import partial
-from rich.console import Console
-from rich.pretty import pprint
 import click
-import csv
-import matplotlib
-import matplotlib.pyplot as plt
-import numpy as np
-import os
+import time
+
 import pandas as pd
-import seaborn as sns
+import plotly.graph_objects as go
+from PIL import Image
+import base64
+from io import BytesIO
+from typing import Callable, Optional, Tuple, List, Union
 
 
 console = Console()
 desktop_path = os.path.expanduser("~/Desktop")
-REQUIRED_COLUMNS = ["epoch", "train_loss", "val_loss", "train_acc", "val_acc"]
-
-import csv
 
+class PlotHelper:
+    def _verify_csv(self, csv_file):
+        """Read a CSV and normalize column names (lowercase)."""
+        try:
+            df = csvfile.read_auto_sep(csv_file)
+            df.columns = [col.lower() for col in df.columns]
+            return df
+        except FileNotFoundError:
+            raise FileNotFoundError(f"CSV file '{csv_file}' not found")
+        except Exception as e:
+            raise ValueError(f"Error reading CSV file '{csv_file}': {str(e)}")
+
+    @staticmethod
+    def _norm_str(s):
+        """Normalize string by converting to lowercase and replacing spaces/underscores."""
+        return s.lower().replace(" ", "_").replace("-", "_")
+
+    @staticmethod
+    def _get_file_name(file_path):
+        """Extract file name without extension."""
+        return os.path.splitext(os.path.basename(file_path))[0]
+
+    def _get_valid_tags(self, csv_files, tags):
+        """Generate tags from file names if not provided."""
+        if tags:
+            return list(tags)
+        return [self._norm_str(self._get_file_name(f)) for f in csv_files]
+
+    def _prepare_long_df(self, csv_files, tags, x_col, y_cols, log=False):
+        """Convert multiple CSVs into a single long-form dataframe for Plotly."""
+        dfs = []
+        for csv_file, tag in zip(csv_files, tags):
+            df = self._verify_csv(csv_file)
+            # Check columns
+            if x_col not in df.columns:
+                raise ValueError(f"{csv_file} is missing x_col '{x_col}'")
+            missing = [c for c in y_cols if c not in df.columns]
+            if missing:
+                raise ValueError(f"{csv_file} is missing y_cols {missing}")
+
+            if log:
+                console.log(f"Plotting {csv_file}")
+                console.print(df)
+
+            # Wide to long
+            df_long = df.melt(
+                id_vars=x_col,
+                value_vars=y_cols,
+                var_name="metric_type",
+                value_name="value",
+            )
+            df_long["tag"] = tag
+            dfs.append(df_long)
+
+        return pd.concat(dfs, ignore_index=True)
+
+    def _plot_with_plotly(
+        self,
+        df_long,
+        tags,
+        outdir,
+        save_fig,
+        out_fmt="svg",
+        font_size=16,
+        x_col="epoch",
+        y_cols=None,
+    ):
+        """Generate Plotly plots for given metrics."""
+        assert out_fmt in ["svg", "pdf", "png"], "Unsupported format"
+        if y_cols is None:
+            raise ValueError("y_cols must be provided")
+
+        # Group by suffix (e.g., "loss", "acc") if names like train_loss exist
+        metric_groups = sorted(set(col.split("_")[-1] for col in y_cols))
+
+        for metric in metric_groups:
+            subset = df_long[df_long["metric_type"].str.contains(metric)]
+
+            if out_fmt == "svg":  # LaTeX-style
+                title = f"${'+'.join(tags)}\\_{metric}\\text{{-by-{x_col}}}$"
+                xaxis_title = f"$\\text{{{x_col.capitalize()}}}$"
+                yaxis_title = f"${metric.capitalize()}$"
+            else:
+                title = f"{'+'.join(tags)}_{metric}-by-{x_col}"
+                xaxis_title = x_col.capitalize()
+                yaxis_title = metric.capitalize()
+
+            fig = px.line(
+                subset,
+                x=x_col,
+                y="value",
+                color="tag",
+                line_dash="metric_type",
+                title=title,
+            )
+            fig.update_layout(
+                font=dict(family="Computer Modern", size=font_size),
+                xaxis_title=xaxis_title,
+                yaxis_title=yaxis_title,
+            )
+            fig.show()
+
+            if save_fig:
+                os.makedirs(outdir, exist_ok=True)
+                timestamp = now_str()
+                filename = f"{timestamp}_{'+'.join(tags)}_{metric}"
+                try:
+                    fig.write_image(os.path.join(outdir, f"{filename}.{out_fmt}"))
+                except Exception as e:
+                    console.log(f"Error saving figure '{filename}.{out_fmt}': {str(e)}")
+
+    @classmethod
+    def plot_csv_timeseries(
+        cls,
+        csv_files,
+        outdir="./out/plot",
+        tags=None,
+        log=False,
+        save_fig=False,
+        update_in_min=0,
+        out_fmt="svg",
+        font_size=16,
+        x_col="epoch",
+        y_cols=["train_loss", "train_acc"],
+    ):
+        """Plot CSV files with Plotly, supporting live updates, as a class method."""
+        if isinstance(csv_files, str):
+            csv_files = [csv_files]
+        if isinstance(tags, str):
+            tags = [tags]
+
+        if not y_cols:
+            raise ValueError("You must specify y_cols explicitly")
+
+        # Instantiate PlotHelper to call instance methods
+        plot_helper = cls()
+        valid_tags = plot_helper._get_valid_tags(csv_files, tags)
+        assert len(valid_tags) == len(
+            csv_files
+        ), "Number of tags must match number of CSV files"
+
+        def run_once():
+            df_long = plot_helper._prepare_long_df(
+                csv_files, valid_tags, x_col, y_cols, log
+            )
+            plot_helper._plot_with_plotly(
+                df_long, valid_tags, outdir, save_fig, out_fmt, font_size, x_col, y_cols
+            )
 
-def get_delimiter(file_path, bytes=4096):
-    sniffer = csv.Sniffer()
-    data = open(file_path, "r").read(bytes)
-    delimiter = sniffer.sniff(data).delimiter
-    return delimiter
+        if update_in_min > 0:
+            interval = int(update_in_min * 60)
+            console.log(f"Live update every {interval}s. Press Ctrl+C to stop.")
+            try:
+                while True:
+                    run_once()
+                    time.sleep(interval)
+            except KeyboardInterrupt:
+                console.log("Stopped live updates.")
+        else:
+            run_once()
+    @staticmethod
+    def plot_image_grid(csv_path, sep=";", max_width=300, max_height=300):
+        """
+        Plot a grid of images using Plotly from a CSV file.
+
+        Args:
+            csv_path (str): Path to CSV file.
+            max_width (int): Maximum width of each image in pixels.
+            max_height (int): Maximum height of each image in pixels.
+        """
+        # Load CSV
+        df = csvfile.read_auto_sep(csv_path, sep=sep)
+
+        # Column names for headers
+        col_names = df.columns.tolist()
+
+        # Function to convert image to base64
+        def pil_to_base64(img_path):
+            with Image.open(img_path) as im:
+                im.thumbnail((max_width, max_height))
+                buffer = BytesIO()
+                im.save(buffer, format="PNG")
+                encoded = base64.b64encode(buffer.getvalue()).decode()
+                return "data:image/png;base64," + encoded
+
+        # Initialize figure
+        fig = go.Figure()
+
+        n_rows = len(df)
+        n_cols = len(df.columns) - 1  # skip label column
+
+        # Add images
+        for i, row in df.iterrows():
+            for j, col in enumerate(df.columns[1:]):
+                img_path = row[col]
+                img_src = pil_to_base64(img_path)
+                fig.add_layout_image(
+                    dict(
+                        source=img_src,
+                        x=j,
+                        y=-i,  # negative to have row 0 on top
+                        xref="x",
+                        yref="y",
+                        sizex=1,
+                        sizey=1,
+                        xanchor="left",
+                        yanchor="top",
+                        layer="above"
+                    )
+                )
+
+        # Set axes for grid layout
+        fig.update_xaxes(
+            tickvals=list(range(n_cols)),
+            ticktext=list(df.columns[1:]),
+            range=[-0.5, n_cols-0.5],
+            showgrid=False,
+            zeroline=False
+        )
+        fig.update_yaxes(
+            tickvals=[-i for i in range(n_rows)],
+            ticktext=df[df.columns[0]],
+            range=[-n_rows + 0.5, 0.5],
+            showgrid=False,
+            zeroline=False
+        )
 
+        fig.update_layout(
+            width=max_width*n_cols,
+            height=max_height*n_rows,
+            margin=dict(l=100, r=20, t=50, b=50)
+        )
 
-# Function to verify that the DataFrame has the required columns, and only the required columns
-def verify_csv(csv_file, required_columns=REQUIRED_COLUMNS):
-    delimiter = get_delimiter(csv_file)
-    df = pd.read_csv(csv_file, sep=delimiter)
-    # change the column names to lower case
-    df.columns = [col.lower() for col in df.columns]
-    for col in required_columns:
-        if col not in df.columns:
-            raise ValueError(
-                f"Required columns are: {REQUIRED_COLUMNS}, but found {df.columns}"
-            )
-    df = df[required_columns].copy()
-    return df
-
-
-def get_valid_tags(csv_files, tags):
-    if tags is not None and len(tags) > 0:
-        assert all(
-            isinstance(tag, str) for tag in tags
-        ), "tags must be a list of strings"
-        assert all(
-            len(tag) > 0 for tag in tags
-        ), "tags must be a list of non-empty strings"
-        valid_tags = tags
-    else:
-        valid_tags = []
-        for csv_file in csv_files:
-            file_name = fs.get_file_name(csv_file, split_file_ext=True)[0]
-            tag = norm_str(file_name)
-            valid_tags.append(tag)
-    return valid_tags
-
-
-def plot_ax(df, ax, metric="loss", tag=""):
-    pprint(locals())
-    # reset plt
-    assert metric in ["loss", "acc"], "metric must be either 'loss' or 'acc'"
-    part = ["train", "val"]
-    for p in part:
-        label = f"{tag}_{p}_{metric}"
-        ax.plot(df["epoch"], df[f"{p}_{metric}"], label=label)
-    return ax
-
-
-def actual_plot_seaborn(frame, csv_files, axes, tags, log):
-    # clear the axes
-    for ax in axes:
-        ax.clear()
-    ls_df = []
-    valid_tags = get_valid_tags(csv_files, tags)
-    for csv_file in csv_files:
-        df = verify_csv(csv_file)
+        fig.show()
+
+    @staticmethod
+    # this plot_df contains the data to be plotted (row, column)
+    def img_grid_df(input_dir, log=False):
+        rows = fs.list_dirs(input_dir)
+        rows = [r for r in rows if r.startswith("row")]
+        meta_dict = {}
+        cols_of_row = None
+        for row in rows:
+            row_path = os.path.join(input_dir, row)
+            cols = sorted(fs.list_dirs(row_path))
+            if cols_of_row is None:
+                cols_of_row = cols
+            else:
+                if cols_of_row != cols:
+                    raise ValueError(
+                        f"Row {row} has different columns than previous rows: {cols_of_row} vs {cols}"
+                    )
+            meta_dict[row] = cols
+
+        meta_dict_with_paths = {}
+        for row, cols in meta_dict.items():
+            meta_dict_with_paths[row] = {
+                col: fs.filter_files_by_extension(
+                    os.path.join(input_dir, row, col), ["png", "jpg", "jpeg"]
+                )
+                for col in cols
+            }
+        first_row = list(meta_dict_with_paths.keys())[0]
+        first_col = list(meta_dict_with_paths[first_row].keys())[0]
+        len_first_col = len(meta_dict_with_paths[first_row][first_col])
+        for row, cols in meta_dict_with_paths.items():
+            for col, paths in cols.items():
+                if len(paths) != len_first_col:
+                    raise ValueError(
+                        f"Row {row}, Column {col} has different number of files: {len(paths)} vs {len_first_col}"
+                    )
+        cols = sorted(meta_dict_with_paths[first_row].keys())
+        rows_set = sorted(meta_dict_with_paths.keys())
+        row_per_col = len(meta_dict_with_paths[first_row][first_col])
+        rows = [item for item in rows_set for _ in range(row_per_col)]
+        data_dict = {}
+        data_dict["row"] = rows
+        col_data = {col: [] for col in cols}
+        for row_base in rows_set:
+            for col in cols:
+                for i in range(row_per_col):
+                    col_data[col].append(meta_dict_with_paths[row_base][col][i])
+        data_dict.update(col_data)
+        df = pd.DataFrame(data_dict)
         if log:
-            with ConsoleLog(f"plotting {csv_file}"):
-                csvfile.fn_display_df(df)
-        ls_df.append(df)
-
-    ls_metrics = ["loss", "acc"]
-    for df_item, tag in zip(ls_df, valid_tags):
-        # add tag to columns,excpet epoch
-        df_item.columns = [
-            f"{tag}_{col}" if col != "epoch" else col for col in df_item.columns
+            csvfile.fn_display_df(df)
+        return df
+
+    @staticmethod
+    def plot_image_grid(
+        csv_file_or_df: Union[str, pd.DataFrame],
+        max_width: int = 300,
+        max_height: int = 300,
+        img_stack_direction: str = "horizontal",
+        img_stack_padding_px: int = 10,
+        format_row_label_func: Optional[Callable[[str], str]] = None,
+        format_col_label_func: Optional[Callable[[str, str], str]] = None,
+        title: str = "",
+    ):
+        """
+        Plot a grid of images using Plotly from a DataFrame.
+
+        Args:
+            df (pd.DataFrame): DataFrame with first column as row labels, remaining columns as image paths.
+            max_width (int): Maximum width of stacked images per cell in pixels.
+            max_height (int): Maximum height of stacked images per cell in pixels.
+            img_stack_direction (str): "horizontal" or "vertical" stacking.
+            img_stack_padding_px (int): Padding between stacked images in pixels.
+            format_row_label_func (Callable): Function to format row labels.
+            format_col_label_func (Callable): Function to format column labels.
+            title (str): Figure title.
+        """
+
+        def stack_images_base64(
+            image_paths: List[str], direction: str, target_size: Tuple[int, int]
+        ) -> str:
+            """Stack images and return base64-encoded PNG."""
+            if not image_paths:
+                return ""
+
+            processed_images = []
+            for path in image_paths:
+                try:
+                    img = Image.open(path).convert("RGB")
+                    img.thumbnail(target_size, Image.Resampling.LANCZOS)
+                    processed_images.append(img)
+                except:
+                    # blank image if error
+                    processed_images.append(Image.new("RGB", target_size, (255, 255, 255)))
+
+            # Stack
+            widths, heights = zip(*(img.size for img in processed_images))
+            if direction == "horizontal":
+                total_width = sum(widths) + img_stack_padding_px * (
+                    len(processed_images) - 1
+                )
+                total_height = max(heights)
+                stacked = Image.new("RGB", (total_width, total_height), (255, 255, 255))
+                x_offset = 0
+                for im in processed_images:
+                    stacked.paste(im, (x_offset, 0))
+                    x_offset += im.width + img_stack_padding_px
+            elif direction == "vertical":
+                total_width = max(widths)
+                total_height = sum(heights) + img_stack_padding_px * (
+                    len(processed_images) - 1
+                )
+                stacked = Image.new("RGB", (total_width, total_height), (255, 255, 255))
+                y_offset = 0
+                for im in processed_images:
+                    stacked.paste(im, (0, y_offset))
+                    y_offset += im.height + img_stack_padding_px
+            else:
+                raise ValueError("img_stack_direction must be 'horizontal' or 'vertical'")
+
+            # Encode as base64
+            buffer = BytesIO()
+            stacked.save(buffer, format="PNG")
+            encoded = base64.b64encode(buffer.getvalue()).decode()
+            return "data:image/png;base64," + encoded
+
+        # Load DataFrame if a file path is provided
+        if isinstance(csv_file_or_df, str):
+            df = csvfile.read_auto_sep(csv_file_or_df)
+        else:
+            df = csv_file_or_df
+        assert isinstance(df, pd.DataFrame), "Input must be a DataFrame or valid CSV file path"
+
+        rows = df[df.columns[0]].tolist()
+        columns = df.columns[1:].tolist()
+        n_rows, n_cols = len(rows), len(columns)
+
+        fig = go.Figure()
+
+        for i, row_label in enumerate(rows):
+            for j, col_label in enumerate(columns):
+                image_paths = df.loc[i, col_label]
+                if isinstance(image_paths, str):
+                    image_paths = [image_paths]
+                img_src = stack_images_base64(
+                    image_paths, img_stack_direction, (max_width, max_height)
+                )
+
+                fig.add_layout_image(
+                    dict(
+                        source=img_src,
+                        x=j,
+                        y=-i,  # negative so row 0 on top
+                        xref="x",
+                        yref="y",
+                        sizex=1,
+                        sizey=1,
+                        xanchor="left",
+                        yanchor="top",
+                        layer="above",
+                    )
+                )
+
+        # Format axis labels
+        col_labels = [
+            format_col_label_func(c, pattern="___") if format_col_label_func else c
+            for c in columns
         ]
-    # merge the dataframes on the epoch column
-    df_combined = ls_df[0]
-    for df_item in ls_df[1:]:
-        df_combined = pd.merge(df_combined, df_item, on="epoch", how="outer")
-    # csvfile.fn_display_df(df_combined)
-
-    for i, metric in enumerate(ls_metrics):
-        tags_str = "+".join(valid_tags) if len(valid_tags) > 1 else valid_tags[0]
-        title = f"{tags_str}_{metric}-by-epoch"
-        cols = [col for col in df_combined.columns if col != "epoch" and metric in col]
-        cols = sorted(cols)
-        # pprint(cols)
-        plot_data = df_combined[cols]
-
-        # line from same csv file (same tag) should have the same marker
-        all_markers = [
-            marker for marker in plt.Line2D.markers if marker and marker != " "
+        row_labels = [
+            format_row_label_func(r) if format_row_label_func else r for r in rows
         ]
-        tag2marker = {tag: marker for tag, marker in zip(valid_tags, all_markers)}
-        plot_markers = []
-        for col in cols:
-            # find the tag:
-            tag = None
-            for valid_tag in valid_tags:
-                if valid_tag in col:
-                    tag = valid_tag
-                    break
-            plot_markers.append(tag2marker[tag])
-        # pprint(list(zip(cols, plot_markers)))
-
-        # create color
-        sequential_palettes = [
-            "Reds",
-            "Greens",
-            "Blues",
-            "Oranges",
-            "Purples",
-            "Greys",
-            "BuGn",
-            "BuPu",
-            "GnBu",
-            "OrRd",
-            "PuBu",
-            "PuRd",
-            "RdPu",
-            "YlGn",
-            "PuBuGn",
-            "YlGnBu",
-            "YlOrBr",
-            "YlOrRd",
-        ]
-        # each csvfile (tag) should have a unique color
-        tag2palette = {
-            tag: palette for tag, palette in zip(valid_tags, sequential_palettes)
-        }
-        plot_colors = []
-        for tag in valid_tags:
-            palette = tag2palette[tag]
-            total_colors = 10
-            ls_colors = sns.color_palette(palette, total_colors).as_hex()
-            num_part = len(ls_metrics)
-            subarr = np.array_split(np.arange(total_colors), num_part)
-            for idx, col in enumerate(cols):
-                if tag in col:
-                    chosen_color = ls_colors[
-                        subarr[int(idx % num_part)].mean().astype(int)
-                    ]
-                    plot_colors.append(chosen_color)
-
-        # pprint(list(zip(cols, plot_colors)))
-        sns.lineplot(
-            data=plot_data,
-            markers=plot_markers,
-            palette=plot_colors,
-            ax=axes[i],
-            dashes=False,
-        )
-        axes[i].set(xlabel="epoch", ylabel=metric, title=title)
-        axes[i].legend()
-        axes[i].grid()
 
-
-def actual_plot(frame, csv_files, axes, tags, log):
-    ls_df = []
-    valid_tags = get_valid_tags(csv_files, tags)
-    for csv_file in csv_files:
-        df = verify_csv(csv_file)
-        if log:
-            with ConsoleLog(f"plotting {csv_file}"):
-                csvfile.fn_display_df(df)
-        ls_df.append(df)
-
-    metric_values = ["loss", "acc"]
-    for i, metric in enumerate(metric_values):
-        for df_item, tag in zip(ls_df, valid_tags):
-            metric_ax = plot_ax(df_item, axes[i], metric, tag)
-
-        # set the title, xlabel, ylabel, legend, and grid
-        tags_str = "+".join(valid_tags) if len(valid_tags) > 1 else valid_tags[0]
-        metric_ax.set(
-            xlabel="epoch", ylabel=metric, title=f"{tags_str}_{metric}-by-epoch"
+        fig.update_xaxes(
+            tickvals=list(range(n_cols)),
+            ticktext=col_labels,
+            range=[-0.5, n_cols - 0.5],
+            showgrid=False,
+            zeroline=False,
         )
-        metric_ax.legend()
-        metric_ax.grid()
-
-
-def plot_csv_files(
-    csv_files,
-    outdir="./out/plot",
-    tags=None,
-    log=False,
-    save_fig=False,
-    update_in_min=1,
-):
-    # if csv_files is a string, convert it to a list
-    if isinstance(csv_files, str):
-        csv_files = [csv_files]
-    # if tags is a string, convert it to a list
-    if isinstance(tags, str):
-        tags = [tags]
-    valid_tags = get_valid_tags(csv_files, tags)
-    assert len(valid_tags) == len(
-        csv_files
-    ), "Unable to determine tags for each csv file"
-    live_update_in_ms = int(update_in_min * 60 * 1000)
-    fig, axes = plt.subplots(2, 1, figsize=(10, 17))
-    if live_update_in_ms:  # live update in min should be > 0
-        from matplotlib.animation import FuncAnimation
-
-        anim = FuncAnimation(
-            fig,
-            partial(
-                actual_plot_seaborn, csv_files=csv_files, axes=axes, tags=tags, log=log
-            ),
-            interval=live_update_in_ms,
-            blit=False,
-            cache_frame_data=False,
+        fig.update_yaxes(
+            tickvals=[-i for i in range(n_rows)],
+            ticktext=row_labels,
+            range=[-n_rows + 0.5, 0.5],
+            showgrid=False,
+            zeroline=False,
         )
-        plt.show()
-    else:
-        actual_plot_seaborn(None, csv_files, axes, tags, log)
-        plt.show()
-
-    if save_fig:
-        os.makedirs(outdir, exist_ok=True)
-        tags_str = "+".join(valid_tags) if len(valid_tags) > 1 else valid_tags[0]
-        tag = f"{now_str()}_{tags_str}"
-        fig.savefig(f"{outdir}/{tag}_plot.png")
-        enable_plot_pgf()
-        fig.savefig(f"{outdir}/{tag}_plot.pdf")
-    if live_update_in_ms:
-        return anim
-
-
-def enable_plot_pgf():
-    matplotlib.use("pdf")
-    matplotlib.rcParams.update(
-        {
-            "pgf.texsystem": "pdflatex",
-            "font.family": "serif",
-            "text.usetex": True,
-            "pgf.rcfonts": False,
-        }
-    )
 
+        fig.update_layout(
+            width=max_width * n_cols + 200,  # extra for labels
+            height=max_height * n_rows + 100,
+            title=title,
+            margin=dict(l=100, r=20, t=50, b=50),
+        )
 
-def save_fig_latex_pgf(filename, directory="."):
-    enable_plot_pgf()
-    if ".pgf" not in filename:
-        filename = f"{directory}/{filename}.pgf"
-    plt.savefig(filename)
+        fig.show()
 
 
-# https: // click.palletsprojects.com/en/8.1.x/api/
 @click.command()
 @click.option("--csvfiles", "-f", multiple=True, type=str, help="csv files to plot")
 @click.option(
-    "--outdir",
-    "-o",
-    type=str,
-    help="output directory for the plot",
-    default=str(desktop_path),
+    "--outdir", "-o", type=str, default=str(desktop_path), help="output directory"
 )
 @click.option(
-    "--tags", "-t", multiple=True, type=str, help="tags for the csv files", default=[]
+    "--tags", "-t", multiple=True, type=str, default=[], help="tags for the csv files"
 )
 @click.option("--log", "-l", is_flag=True, help="log the csv files")
-@click.option("--save_fig", "-s", is_flag=True, help="save the plot as a file")
+@click.option("--save_fig", "-s", is_flag=True, help="save the plot as file")
 @click.option(
     "--update_in_min",
     "-u",
     type=float,
-    help="update the plot every x minutes",
     default=0.0,
+    help="update the plot every x minutes",
+)
+@click.option(
+    "--x_col", "-x", type=str, default="epoch", help="column to use as x-axis"
 )
-def main(
-    csvfiles,
-    outdir,
-    tags,
-    log,
-    save_fig,
-    update_in_min,
-):
-    plot_csv_files(list(csvfiles), outdir, list(tags), log, save_fig, update_in_min)
+@click.option(
+    "--y_cols",
+    "-y",
+    multiple=True,
+    type=str,
+    required=True,
+    help="columns to plot as y (can repeat)",
+)
+def main(csvfiles, outdir, tags, log, save_fig, update_in_min, x_col, y_cols):
+    PlotHelper.plot_csv_timeseries(
+        list(csvfiles),
+        outdir,
+        list(tags),
+        log,
+        save_fig,
+        update_in_min,
+        x_col=x_col,
+        y_cols=list(y_cols),
+    )
 
 
 if __name__ == "__main__":

{halib-0.1.85.dist-info → halib-0.1.87.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: halib
-Version: 0.1.85
+Version: 0.1.87
 Summary: Small library for common tasks
 Author: Hoang Van Ha
 Author-email: hoangvanhauit@gmail.com
@@ -52,7 +52,7 @@ Dynamic: summary
 
 Helper package for coding and automation
 
-**Version 0.1.85**
+**Version 0.1.87**
 
 + `research/profiler`: add `zProfiler` class to measure execution time of contexts and steps, with support for dynamic color scales in plots.
 

{halib-0.1.85.dist-info → halib-0.1.87.dist-info}/RECORD

@@ -17,7 +17,7 @@ halib/textfile.py,sha256=EhVFrit-nRBJx18e6rtIqcE1cSbgsLnMXe_kdhi1EPI,399
 halib/torchloader.py,sha256=-q9YE-AoHZE1xQX2dgNxdqtucEXYs4sQ22WXdl6EGfI,6500
 halib/videofile.py,sha256=NTLTZ-j6YD47duw2LN2p-lDQDglYFP1LpEU_0gzHLdI,4737
 halib/filetype/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-halib/filetype/csvfile.py,sha256=YtJHYft72I4VmKo9QpMv6TPV_62chcwdAIyRRumJKOI,5727
+halib/filetype/csvfile.py,sha256=4Klf8YNzY1MaCD3o5Wp5GG3KMfQIBOEVzHV_7DO5XBo,6604
 halib/filetype/jsonfile.py,sha256=9LBdM7LV9QgJA1bzJRkq69qpWOP22HDXPGirqXTgSCw,480
 halib/filetype/textfile.py,sha256=QtuI5PdLxu4hAqSeafr3S8vCXwtvgipWV4Nkl7AzDYM,399
 halib/filetype/videofile.py,sha256=4nfVAYYtoT76y8P4WYyxNna4Iv1o2iV6xaMcUzNPC4s,4736
@@ -29,13 +29,14 @@ halib/online/gdrive_test.py,sha256=hMWzz4RqZwETHp4GG4WwVNFfYvFQhp2Boz5t-DqwMo0,1
 halib/online/projectmake.py,sha256=Zrs96WgXvO4nIrwxnCOletL4aTBge-EoF0r7hpKO1w8,4034
 halib/research/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 halib/research/base_config.py,sha256=AIjVzl2ZJ9b8yIGb2X5EZwLmyGJ_9wNWqrib1nU3Wj0,2831
-halib/research/base_exp.py,sha256=tz03FF2XMI9b6Ram4ZJBjKo053Vb7T8yTTCH0jeLvp4,3218
+halib/research/base_exp.py,sha256=hiO2flt_I0iJJ4bWcQwyh2ISezoC8t2k3PtxHeVr0eI,3278
 halib/research/benchquery.py,sha256=FuKnbWQtCEoRRtJAfN-zaN-jPiO_EzsakmTOMiqi7GQ,4626
 halib/research/dataset.py,sha256=QU0Hr5QFb8_XlvnOMgC9QJGIpwXAZ9lDd0RdQi_QRec,6743
 halib/research/metrics.py,sha256=Xgv0GUGo-o-RJaBOmkRCRpQJaYijF_1xeKkyYU_Bv4U,5249
+halib/research/mics.py,sha256=uX17AGrBGER-OFMqUULE_A9YPPbn1RpQ4o5-omrmqZ8,377
 halib/research/perfcalc.py,sha256=qDa0sqfpWrwGZVJtjuUVFK7JX6j8xyXP9OnnfYmdamg,15898
 halib/research/perftb.py,sha256=FWg0b8wSgy4UwuvHSXwEqvTq1Rhi-z-HtAKuQg1lWc4,30989
-halib/research/plot.py,sha256=-pDUk4z3C_GnyJ5zWmf-mGMdT4gaipVJWzIgcpIPiRk,9448
+halib/research/plot.py,sha256=A3di1HZhIHIKf7d9b-I68yu_cm4u2LpHoPKlirCaNOI,17956
 halib/research/profiler.py,sha256=a5ndHzVCatmHIBm4Z2e7F41hJLCu-u3g97pq490mPrg,11770
 halib/research/torchloader.py,sha256=yqUjcSiME6H5W210363HyRUrOi3ISpUFAFkTr1w4DCw,6503
 halib/research/wandb_op.py,sha256=YzLEqME5kIRxi3VvjFkW83wnFrsn92oYeqYuNwtYRkY,4188
@@ -52,8 +53,8 @@ halib/utils/gpu_mon.py,sha256=vD41_ZnmPLKguuq9X44SB_vwd9JrblO4BDzHLXZhhFY,2233
 halib/utils/listop.py,sha256=Vpa8_2fI0wySpB2-8sfTBkyi_A4FhoFVVvFiuvW8N64,339
 halib/utils/tele_noti.py,sha256=-4WXZelCA4W9BroapkRyIdUu9cUVrcJJhegnMs_WpGU,5928
 halib/utils/video.py,sha256=ZqzNVPgc1RZr_T0OlHvZ6SzyBpL7O27LtB86JMbBuR0,3059
-halib-0.1.85.dist-info/licenses/LICENSE.txt,sha256=qZssdna4aETiR8znYsShUjidu-U4jUT9Q-EWNlZ9yBQ,1100
-halib-0.1.85.dist-info/METADATA,sha256=SS6kkHfSSjX02VYgLLQEqxmS86EhxjqnWqE-y3cvAYg,5864
-halib-0.1.85.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-halib-0.1.85.dist-info/top_level.txt,sha256=7AD6PLaQTreE0Fn44mdZsoHBe_Zdd7GUmjsWPyQ7I-k,6
-halib-0.1.85.dist-info/RECORD,,
+halib-0.1.87.dist-info/licenses/LICENSE.txt,sha256=qZssdna4aETiR8znYsShUjidu-U4jUT9Q-EWNlZ9yBQ,1100
+halib-0.1.87.dist-info/METADATA,sha256=EEx-vMyPJvloMv-e87rnnlWS1mBwdAz9oBP6TZQIzOY,5864
+halib-0.1.87.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+halib-0.1.87.dist-info/top_level.txt,sha256=7AD6PLaQTreE0Fn44mdZsoHBe_Zdd7GUmjsWPyQ7I-k,6
+halib-0.1.87.dist-info/RECORD,,