| import enum |
| import os |
| from pathlib import Path |
|
|
| import click |
| import matplotlib.pyplot as plt |
| import polars as pl |
|
|
|
|
| class ImageFormat(enum.Enum): |
| PNG = "png" |
| JPEG = "jpg" |
|
|
|
|
| @click.command() |
| @click.option( |
| "--src_dir", |
| type=click.Path(exists=True, file_okay=False), |
| required=True, |
| help="Path to the directory containing dataset, e.g., './data'.", |
| ) |
| @click.option( |
| "--dst_dir", |
| type=click.Path(file_okay=False), |
| required=False, |
| help="Path to the directory where statisics will be saved. " |
| "If not specified, statistics is saved in '{src_dir}/stats'. e.g., './stats'.", |
| ) |
| @click.option( |
| "--file_name", |
| type=str, |
| default="multi_event", |
| help="Base name for multi-event file. Default is 'multi_event'.", |
| ) |
| def cli(src_dir: str, dst_dir: str, file_name: str): |
| if dst_dir is None: |
| dst_dir = f"{src_dir}/stats" |
| generate_dataset_stats(src_dir, dst_dir, file_name) |
|
|
|
|
| def generate_dataset_stats(src_dir: str, dst_dir: str, file_name: str): |
| src_dir, dst_dir = Path(src_dir), Path(dst_dir) |
| src_dir_flat, src_dir_seq = src_dir / "flat", src_dir / "sequential" |
|
|
| file_name = f"{file_name}.parquet" |
| sizes = sorted(path.name for path in src_dir_flat.iterdir()) |
| for size in sizes: |
| path_flat, path_seq = src_dir_flat / size, src_dir_seq / size |
| assert path_seq.exists(), f"Cannot find sequential data in '{path_seq}'" |
| assert (path_flat / file_name).exists(), ( |
| "Please, generate flat multi-event file using " |
| "'make_multievent.py' or specify correct name using --file_name" |
| ) |
| assert (path_seq / file_name).exists(), ( |
| "Please, generate sequential multi-event file " |
| "using 'transform2sequential.py' script or specify correct name " |
| "using --file_name" |
| ) |
|
|
| print(f"Gathering stats for {size}...") |
| dst_dir_size = dst_dir / size |
| dst_dir_size.mkdir(parents=True, exist_ok=True) |
|
|
| df = pl.scan_parquet(path_seq / file_name) |
| generate_user_history_graph(df, dst_dir_size / "user_history_len.png") |
| generate_log_user_history_graph(df, dst_dir_size / "user_history_log_len.png") |
|
|
| df = pl.scan_parquet(path_flat / file_name) |
| generate_item_interactions_graph(df, dst_dir_size / "item_interactions.png") |
| get_recom_stats(df).write_csv(dst_dir_size / "recom_event_count.csv") |
| get_history_len_stats(df).write_csv(dst_dir_size / "event_history_len.csv") |
| get_dataset_stats(df).write_csv(dst_dir_size / "dataset_event_stats.csv") |
|
|
|
|
| def make_history_len_graph( |
| df: pl.DataFrame, |
| *, |
| qs: tuple[float] | None = None, |
| color: str = "lightskyblue", |
| num_bins: int = 100, |
| title: str | None = None, |
| xlabel: str | None = None, |
| ylabel: str | None = None, |
| ax: plt.Axes | None = None, |
| ) -> plt.Axes: |
| if ax is None: |
| _, ax = plt.subplots(figsize=(12, 5)) |
|
|
| count, _, _ = ax.hist(df["value"], bins=num_bins, ec="k", lw=1.0, color=color) |
| ylim = count.max() * 1.05 |
|
|
| xs = {"max": df["value"].max()} |
| if qs is not None: |
| xs.update((f"q{q * 100:.0f}", df["value"].quantile(q)) for q in qs) |
|
|
| dx = 0.01 * (xs["max"] - df["value"].min()) |
| template = "{label}={x:.3f}" if xs["max"] <= 10 else "{label}={x:.0f}" |
| for label, x in xs.items(): |
| ax.plot([x, x], [0, ylim], ls="--", c="k") |
| text = template.format(label=label, x=x) |
| ax.text(x + dx, ylim // 2, text, rotation=90, fontsize=16, bbox=dict(alpha=0.1, color="r")) |
|
|
| if title is not None: |
| ax.set_title(title, fontsize=24) |
| ax.set_xlabel(xlabel or "Value", fontsize=22) |
| ax.set_ylabel(ylabel or "Count", fontsize=22) |
|
|
| ax.set_ylim([0, ylim]) |
|
|
| ax.tick_params(labelsize=16) |
| ax.ticklabel_format(style="sci", useMathText=True) |
|
|
|
|
| def save_graph(output_path: os.PathLike, fmt: ImageFormat = ImageFormat.PNG): |
| output_path = Path(output_path) |
| if not output_path.suffix: |
| output_path = output_path.with_suffix(f".{fmt.value}") |
|
|
| if output_path.exists(): |
| print(f"Rewriting file '{output_path}'") |
| else: |
| print(f"Saving to '{output_path}'") |
|
|
| plt.savefig(output_path, dpi=300, format=fmt.value) |
|
|
|
|
| def generate_user_history_graph(df: pl.LazyFrame, out_path: os.PathLike): |
| _, ax = plt.subplots(figsize=(12, 5)) |
|
|
| make_history_len_graph( |
| df.select(value=pl.col("item_id").list.len()).collect(), |
| num_bins=100, |
| qs=(0.5, 0.9, 0.95), |
| xlabel="Events", |
| ylabel="Users", |
| ax=ax, |
| ) |
| plt.tight_layout() |
| save_graph(out_path) |
|
|
|
|
| def generate_log_user_history_graph(df: pl.LazyFrame, out_path: os.PathLike): |
| _, ax = plt.subplots(figsize=(12, 5)) |
|
|
| make_history_len_graph( |
| df.select(value=pl.col("item_id").list.len().log10()).collect(), |
| num_bins=40, |
| xlabel="$Log_{10}$(Events)", |
| ylabel="Users", |
| color="lightgreen", |
| ax=ax, |
| ) |
| plt.tight_layout() |
| save_graph(out_path) |
|
|
|
|
| def generate_item_interactions_graph(df: pl.LazyFrame, out_path: os.PathLike): |
| _, ax = plt.subplots(figsize=(12, 5)) |
|
|
| make_history_len_graph( |
| df.group_by("item_id").len().select(value=pl.col("len").log10()).collect(), |
| num_bins=30, |
| qs=(0.5, 0.9, 0.95), |
| xlabel="$Log_{10}$(Events)", |
| ylabel="Items", |
| color="orange", |
| ax=ax, |
| ) |
| plt.tight_layout() |
| save_graph(out_path) |
|
|
|
|
| def get_recom_stats(df: pl.LazyFrame) -> pl.DataFrame: |
| print("Computing recom stats") |
| df_cnt = df.group_by(("event_type", "is_organic")).len().collect() |
| df_recom = df_cnt.filter(pl.col("is_organic").eq(0)).select(pl.col("event_type"), pl.col("len").alias("recom")) |
| df_total = df_cnt.group_by("event_type").sum().select(pl.col("event_type"), pl.col("len").alias("total")) |
| return df_total.join(df_recom, on="event_type").with_columns(ratio=pl.col("recom") / pl.col("total")) |
|
|
|
|
| def get_history_len_stats(df: pl.LazyFrame) -> pl.DataFrame: |
| print("Computing event history length stats") |
| return ( |
| df.group_by(("event_type", "uid")) |
| .len() |
| .group_by("event_type") |
| .agg( |
| median=pl.col("len").quantile(0.5).cast(pl.Int32), |
| q90=pl.col("len").quantile(0.9).cast(pl.Int32), |
| q95=pl.col("len").quantile(0.95).cast(pl.Int32), |
| ) |
| .collect() |
| ) |
|
|
|
|
| def get_dataset_stats(df: pl.LazyFrame) -> pl.DataFrame: |
| print("Computing dataset stats") |
| return df.select( |
| users=pl.col("uid").unique().len(), |
| items=pl.col("item_id").unique().len(), |
| listens=pl.col("event_type").filter(pl.col("event_type").eq("listen")).len(), |
| likes=pl.col("event_type").filter(pl.col("event_type").eq("like")).len(), |
| dislikes=pl.col("event_type").filter(pl.col("event_type").eq("dislike")).len(), |
| unlikes=pl.col("event_type").filter(pl.col("event_type").eq("unlike")).len(), |
| undislikes=pl.col("event_type").filter(pl.col("event_type").eq("undislike")).len(), |
| ).collect() |
|
|
|
|
| if __name__ == "__main__": |
| cli() |
|
|
