retrieval_fiqa_generowanie_20.py

# === FIQA: porównanie metryk dla 20 pierwszych (bez/adaptive K) ===


fiqa_first_20 = {
    "NDCG": {
        "NDCG@4": 0.38466,
        "NDCG@8": 0.4044,
        "NDCG@16": 0.4044,
    },
    "MAP": {
        "MAP@4": 0.32708,
        "MAP@8": 0.33667,
        "MAP@16": 0.33667,
    },
    "Recall": {
        "Recall@4": 0.48333,
        "Recall@8": 0.54167,
        "Recall@16": 0.54167,
    },
    "Precision": {
        "P@4": 0.15,
        "P@8": 0.0875,
        "P@16": 0.04375,
    },
}

# z adaptive K

fiqa_first_20_adaptive_k_buffer_5 = {
    "NDCG": {
        "NDCG@4": 0.38466,
        "NDCG@8": 0.38863,
        "NDCG@16": 0.38863,
    },
    "MAP": {
        "MAP@4": 0.32708,
        "MAP@8": 0.33042,
        "MAP@16": 0.33042,
    },
    "Recall": {
        "Recall@4": 0.48333,
        "Recall@8": 0.49167,
        "Recall@16": 0.49167,
    },
    "Precision": {
        "P@4": 0.15,
        "P@8": 0.08125,
        "P@16": 0.04063,
    },
}


import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import Patch
import re

BASE = fiqa_first_20
ADAPT = fiqa_first_20_adaptive_k_buffer_5


def _parse_ks(metric_dict):
    ks = []
    for key in metric_dict.keys():
        m = re.search(r"@(\d+)", key)
        if m:
            ks.append(int(m.group(1)))
    return sorted(set(ks))


def _prefix(metric):
    return "P" if metric == "Precision" else metric


def _vals(dct, metric, ks):
    pref = _prefix(metric)
    return [dct[metric][f"{pref}@{k}"] for k in ks]


def plot_grouped_pair(metrics_subset, base_dict, adapt_dict, title, outfile):
    ks = _parse_ks(base_dict[metrics_subset[0]])
    # Ustal pozycje: dla każdej metryki 3 podgrupy (k) i w każdej para (baseline/adaptive)
    # x_metrics = np.arange(len(metrics_subset))

    group_sep = 0.8  # >1 zwiększa przerwę między grupami, np. 1.15–1.35
    x_metrics = np.arange(len(metrics_subset)) * group_sep

    bar_width = 0.10  # węższe słupki
    inner_gap = 0.04  # mniejszy odstęp między podgrupami @k
    pair_gap = 0.02  # mniejszy odstęp w parze baseline/adaptive

    # Kolory dla k (spójne w obu wykresach)
    colors_k = {ks[0]: "#0EA5E9", ks[1]: "#F59E0B", ks[2]: "#10B981"}
    # Hatching: baseline vs adaptive
    hatch_base, hatch_adapt = "", "//"

    fig, ax = plt.subplots(figsize=(10, 5))

    # Rysuj słupki
    for m_idx, metric in enumerate(metrics_subset):
        base_vals = _vals(base_dict, metric, ks)
        adapt_vals = _vals(adapt_dict, metric, ks)

        for i, k in enumerate(ks):
            # centrum podgrupy k w obrębie metryki
            center = x_metrics[m_idx] + (i - (len(ks) - 1) / 2) * (
                2 * bar_width + inner_gap
            )
            x_base = center - (bar_width / 2 + pair_gap / 2)
            x_adapt = center + (bar_width / 2 + pair_gap / 2)

            b1 = ax.bar(
                x_base,
                base_vals[i],
                width=bar_width,
                color=colors_k[k],
                edgecolor="black",
                linewidth=0.4,
                hatch=hatch_base,
                label=None,
            )
            b2 = ax.bar(
                x_adapt,
                adapt_vals[i],
                width=bar_width,
                color=colors_k[k],
                edgecolor="black",
                linewidth=0.4,
                hatch=hatch_adapt,
                label=None,
            )

            # adnotacje
            for b, val in [(b1[0], base_vals[i]), (b2[0], adapt_vals[i])]:
                ax.annotate(
                    f"{val:.3f}",
                    (b.get_x() + b.get_width() / 2, val),
                    ha="center",
                    va="bottom",
                    fontsize=8,
                    xytext=(0, 6),
                    textcoords="offset points",
                )

    # Oś X i opis
    ax.set_title(title)
    ax.set_xlabel("Metryka")
    ax.set_ylabel("Wartość (0–1)")
    ax.set_xticks(x_metrics)
    ax.set_xticklabels(metrics_subset)
    ax.set_ylim(0, 1.0)
    ax.set_axisbelow(True)
    ax.grid(axis="y", alpha=0.25)
    ax.spines["top"].set_visible(False)
    ax.spines["right"].set_visible(False)

    # Dwie legendy: k (kolory) oraz system (hatch)

    # --- LEGENDA: obie w prawym górnym rogu ---
    k_patches = [
        Patch(facecolor=colors_k[k], edgecolor="black", label=f"@{k}") for k in ks
    ]
    sys_patches = [
        Patch(
            facecolor="#CCCCCC",
            edgecolor="black",
            hatch=hatch_base,
            label="Baseline (bez adaptive)",
        ),
        Patch(
            facecolor="#CCCCCC",
            edgecolor="black",
            hatch=hatch_adapt,
            label="Adaptive K (buffer=5)",
        ),
    ]

    # pierwsza legenda (k) w samym rogu
    leg1 = ax.legend(
        handles=k_patches,
        title="Głębokość @k",
        loc="upper right",
        bbox_to_anchor=(1.0, 1.0),
    )
    ax.add_artist(leg1)

    # druga legenda (system) tuż pod pierwszą
    ax.legend(
        handles=sys_patches,
        title="System",
        loc="upper right",
        bbox_to_anchor=(1.0, 0.72),
    )

    plt.tight_layout()
    plt.savefig(outfile, dpi=200, bbox_inches="tight", pad_inches=0.1)
    plt.show()
    print(f"Zapisano: {outfile}")


# --- WYKRES 1: NDCG + MAP ---
plot_grouped_pair(
    metrics_subset=["NDCG", "MAP"],
    base_dict=BASE,
    adapt_dict=ADAPT,
    title="FIQA (Top-20): NDCG i MAP – fixed vs adaptive K",
    outfile="fiqa_ndcg_map_baseline_vs_adaptive.png",
)

# --- WYKRES 2: Recall + Precision ---
plot_grouped_pair(
    metrics_subset=["Recall", "Precision"],
    base_dict=BASE,
    adapt_dict=ADAPT,
    title="FIQA (Top-20): " "Recall i Precision – fixed vs adaptive K",
    outfile="fiqa_recall_precision_baseline_vs_adaptive.png",
)