| import sys |
| from vre.readers import MultiTaskDataset |
| from vre.representations import build_representations_from_cfg, Representation |
| from vre.representations.cv_representations import SemanticRepresentation |
| from vre.logger import vre_logger as logger |
| import matplotlib.pyplot as plt |
| import numpy as np |
| import pandas as pd |
| import io |
| import base64 |
| import bs4 |
| from PIL import Image |
| import seaborn as sns |
|
|
| def extract_pil_from_b64_image(base64_buf: str) -> Image: |
| return Image.open(io.BytesIO(base64.b64decode(base64_buf))) |
|
|
| def extract_b64_image_from_fig(fig: plt.Figure) -> str: |
| buffer = io.BytesIO() |
| fig.savefig(buffer, format="png", dpi=fig.dpi) |
| buffer.seek(0) |
| base64_buf = base64.b64encode(buffer.getvalue()).decode("utf-8") |
| return base64_buf |
|
|
| def extract_b64_imgsrc_from_fig(fig: plt.Figure) -> str: |
| base64_buf = extract_b64_image_from_fig(fig) |
| return f"""<img src="data:image/png;base64,{base64_buf}" alt="Sample Plot">""" |
|
|
| def save_html(html_imgs: list[str], description: str, out_path: str): |
| html = bs4.BeautifulSoup(f""" |
| <!DOCTYPE html> |
| <html> |
| <head> |
| <title>VRE Dataset Analysis</title> |
| </head> |
| <body> |
| <h1 id="description">Description</h1> |
| <h1 id="plots">Plots</h1> |
| </body> |
| </html>""", features="lxml") |
| html.find(id="description").insert_after(bs4.BeautifulSoup(description.replace("\n", "<br/>"), features="lxml")) |
| for html_img in html_imgs[::-1]: |
| html.find(id="plots").insert_after(bs4.BeautifulSoup(html_img, features="lxml")) |
| open(out_path, "w").write(str(html)) |
| print(f"Written html at '{out_path}'") |
|
|
|
|
| def histogram_from_classification_task(reader: MultiTaskDataset, classif: SemanticRepresentation, |
| n: int | None = None, mode: str = "sequential", **figkwargs) -> plt.Figure: |
| fig = plt.Figure(**figkwargs) |
| counts = np.zeros(len(classif.classes), dtype=np.uint64) |
| ixs = np.arange(len(reader)) if mode == "sequential" else np.random.permutation(len(reader)) |
| ixs = ixs[0:n] if n is not None and n < len(reader) else ixs |
| assert getattr(classif, "load_mode", "binary") == "binary", classif.load_mode |
| for i in ixs: |
| item = reader.get_one_item(i.item(), subset_tasks=[classif.name]) |
| data_cnts = item[0][classif.name].unique(return_counts=True) |
| item_classes, item_counts = data_cnts[0].numpy().astype(int), data_cnts[1].numpy().astype(int) |
| counts[item_classes] = counts[item_classes] + item_counts |
|
|
| df = pd.DataFrame({"Labels": classif.classes, "Values": counts}) |
| df["Values"] = df["Values"] / df["Values"].sum() |
| df = df.sort_values("Values", ascending=True) |
| df = df[df["Values"] > 0.005] |
|
|
| ax = fig.gca() |
| sns.barplot(data=df, y="Labels", x="Values", palette="viridis", legend=True, ax=ax, width=1) |
|
|
| |
| ax.set_title(classif.name, fontsize=14, fontweight='bold') |
| ax.set_ylabel("Labels", fontsize=12) |
|
|
| fig.set_size_inches(8, 2 if len(df) <= 2 else len(df) * 0.5) |
| fig.gca().set_xlim(0, 1) |
| fig.tight_layout() |
| plt.close() |
| return fig |
|
|
| def gaussian_from_statistics(reader: MultiTaskDataset, regression_task: Representation) -> plt.Figure: |
| _, __, mean, std = [x.numpy() for x in reader.statistics[regression_task.name]] |
| fig, ax = plt.subplots(1, n_ch := mean.shape[0], figsize=(10, 5)) |
| ax = [ax] if n_ch == 1 else ax |
| x = np.linspace(mean - 4*std, mean + 4*std, 1000) |
| y = (1 / (std * np.sqrt(2 * np.pi))) * np.exp(-0.5 * ((x - mean) / std) ** 2) |
| for i in range(n_ch): |
| ax[i].plot(x[:, i], y[:, i]) |
| fig.suptitle(regression_task.name) |
| return fig |
|
|
| if __name__ == "__main__": |
| data_path = sys.argv[1] |
| cfg_path = sys.argv[2] |
| representations = build_representations_from_cfg(cfg_path) |
| print(representations) |
| reader = MultiTaskDataset(data_path, task_names=list(representations), |
| task_types=representations, normalization="min_max") |
| print(reader) |
|
|
| imgsrcs = [] |
| for classif_task in reader.classification_tasks: |
| fig = histogram_from_classification_task(reader, classif_task) |
| imgsrcs.append(extract_b64_imgsrc_from_fig(fig)) |
|
|
| regression_tasks = [t for t in reader.tasks if t not in reader.classification_tasks] |
| for regression_task in regression_tasks: |
| fig = gaussian_from_statistics(reader, regression_task) |
| imgsrcs.append(extract_b64_imgsrc_from_fig(fig)) |
|
|
| save_html(imgsrcs, str(reader), "plot.html") |
|
|
