|
|
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() |
|
|
|
