plotlibs 0.3.0__py3-none-any.whl

plotlibs/ml.py

@@ -0,0 +1,205 @@
+"""plotlibs.ml — رسوم تعلم الآلة والتعلم العميق (تُشهر المكتبة عند ML/DL).
+
+تعمل بـ numpy فقط — لا تحتاج sklearn/keras للرسم، لكن تقبل مخرجاتها.
+
+    import plotlibs as pl
+    pl.plot_history({"loss": [...], "val_loss": [...]})
+    pl.plot_confusion_matrix(y_true, y_pred)
+    pl.plot_roc(y_true, y_score)
+    pl.plot_feature_importance(names, values)
+    pl.plot_images(images)  # للتعلم العميق / رؤية حاسوبية
+"""
+from __future__ import annotations
+
+import numpy as np
+
+
+def _plt():
+    from . import pyplot as plt
+    return plt
+
+
+def plot_history(history, metrics=("loss",), savefig=None, title="training history", smooth: int = 1):
+    """ارسم history من Keras (dict) أو DataFrame أو dict of lists.
+
+    history = {"loss": [...], "val_loss": [...], "accuracy": [...]}
+    """
+    plt = _plt()
+    if hasattr(history, "history"):  # keras History object
+        history = history.history
+    if hasattr(history, "to_dict"):
+        try:
+            history = history.to_dict(orient="list")
+        except Exception:
+            pass
+    keys = [k for k in history.keys() if not k.startswith("val_")] if isinstance(history, dict) else []
+    if not keys and isinstance(history, dict):
+        keys = list(history.keys())
+    if metrics == ("loss",) and keys:
+        # تلقائياً: كل المقاييس الموجودة
+        metrics = tuple(keys)
+    fig_axes = []
+    for m in metrics:
+        train = np.asarray(history[m], dtype=float).ravel() if m in history else None
+        val = np.asarray(history.get(f"val_{m}", []), dtype=float).ravel() if isinstance(history, dict) else None
+        if train is None:
+            continue
+        if smooth > 1 and train.size >= smooth:
+            train = np.convolve(train, np.ones(smooth) / smooth, mode="same")
+        plt.figure()
+        plt.plot(train, label=f"train {m}")
+        if val is not None and val.size:
+            plt.plot(val, label=f"val {m}")
+        plt.xlabel("epoch")
+        plt.ylabel(m)
+        plt.title(title if len(metrics) == 1 else f"{title} — {m}")
+        plt.legend()
+        plt.grid(True)
+        fig_axes.append(plt.gcf())
+        if savefig and len(metrics) == 1:
+            plt.savefig(savefig)
+    return fig_axes[0] if len(fig_axes) == 1 else fig_axes
+
+
+def confusion_matrix_data(y_true, y_pred, labels=None):
+    y_true = np.asarray(y_true).ravel()
+    y_pred = np.asarray(y_pred).ravel()
+    n = min(y_true.size, y_pred.size)
+    y_true, y_pred = y_true[:n], y_pred[:n]
+    if labels is None:
+        labels = sorted(map(str, np.unique(np.concatenate([y_true, y_pred]))))
+    lab_to_i = {str(l): i for i, l in enumerate(labels)}
+    cm = np.zeros((len(labels), len(labels)), dtype=float)
+    for t, p in zip(y_true, y_pred):
+        i = lab_to_i.get(str(t))
+        j = lab_to_i.get(str(p))
+        if i is not None and j is not None:
+            cm[i, j] += 1
+    return cm, labels
+
+
+def plot_confusion_matrix(y_true=None, y_pred=None, cm=None, labels=None,
+                          normalize: bool = False, title="confusion matrix", **kw):
+    """مصفوفة الالتباس — تقبل (y_true, y_pred) أو مصفوفة جاهزة cm."""
+    plt = _plt()
+    if cm is None:
+        if y_true is None or y_pred is None:
+            raise ValueError("pass (y_true, y_pred) or cm=")
+        cm, labels = confusion_matrix_data(y_true, y_pred, labels)
+    else:
+        cm = np.asarray(cm, dtype=float)
+        labels = labels or [str(i) for i in range(cm.shape[0])]
+    disp = cm / cm.sum(axis=1, keepdims=True).clip(min=1) if normalize else cm
+    plt.gca().heatmap(disp, xticks=labels, yticks=labels, annot=True, cmap="viridis")
+    plt.title(title + (" (normalized)" if normalize else ""))
+    plt.xlabel("predicted")
+    plt.ylabel("true")
+    return disp
+
+
+def plot_roc(y_true, y_score, label="", **kw):
+    """منحنى ROC + AUC (numpy فقط)."""
+    from .fast import roc_from_scores
+    plt = _plt()
+    fpr, tpr, auc = roc_from_scores(y_true, y_score)
+    plt.plot(fpr, tpr, label=f"{label} AUC={auc:.3f}" if label else f"AUC={auc:.3f}")
+    plt.plot([0, 1], [0, 1], linestyle="--", color="gray")
+    plt.xlabel("FPR")
+    plt.ylabel("TPR")
+    plt.title("ROC curve")
+    plt.legend()
+    plt.grid(True)
+    return fpr, tpr, auc
+
+
+def plot_pr(y_true, y_score, label="", **kw):
+    """منحنى Precision-Recall + AP."""
+    from .fast import pr_from_scores
+    plt = _plt()
+    rec, prec, ap = pr_from_scores(y_true, y_score)
+    plt.plot(rec, prec, label=f"{label} AP={ap:.3f}" if label else f"AP={ap:.3f}")
+    plt.xlabel("recall")
+    plt.ylabel("precision")
+    plt.title("precision-recall curve")
+    plt.legend()
+    plt.grid(True)
+    return rec, prec, ap
+
+
+def plot_feature_importance(names, values, top: int = 20, title="feature importance", **kw):
+    """أهمية الميزات (XGBoost/sklearn/RF) كأشرطة أفقية مرتبة."""
+    plt = _plt()
+    names = np.asarray(names).ravel()
+    values = np.asarray(values, dtype=float).ravel()
+    n = min(names.size, values.size)
+    names, values = names[:n], values[:n]
+    order = np.argsort(values, kind="stable")[-top:]
+    plt.barh([str(names[i]) for i in order], values[order])
+    plt.title(title)
+    plt.grid(True)
+    return order
+
+
+def plot_residuals(y_true, y_pred, title="residuals", **kw):
+    """بقايا الانحدار: predicted مقابل residual + هستوغرام."""
+    plt = _plt()
+    y_true = np.asarray(y_true, dtype=float).ravel()
+    y_pred = np.asarray(y_pred, dtype=float).ravel()
+    n = min(y_true.size, y_pred.size)
+    res = y_true[:n] - y_pred[:n]
+    fig, axs = plt.subplots(1, 2, figsize=(10, 4))
+    axs[0].scatter(y_pred[:n], res)
+    axs[0].axhline(0)
+    axs[0].set_xlabel("predicted")
+    axs[0].set_ylabel("residual")
+    axs[0].set_title(title)
+    axs[1].hist(res, bins=30)
+    axs[1].set_title("residual dist")
+    fig.suptitle(title)
+    return res
+
+
+def plot_elbow(k_list, inertia, title="elbow method", **kw):
+    plt = _plt()
+    plt.plot(np.asarray(k_list), np.asarray(inertia, dtype=float), marker="o")
+    plt.xlabel("k")
+    plt.ylabel("inertia")
+    plt.title(title)
+    plt.grid(True)
+
+
+def plot_images(images, ncols: int = 8, max_images: int = 64, title="", cmap="gray", **kw):
+    """شبكة صور للتعلم العميق (MNIST/CIFAR) — numpy فقط."""
+    plt = _plt()
+    arr = np.asarray(images)
+    if arr.ndim == 3:
+        arr = arr[:max_images]
+    elif arr.ndim == 4:
+        arr = arr[:max_images]
+    else:
+        raise ValueError("images must be (N,H,W) or (N,H,W,C)")
+    n = arr.shape[0]
+    ncols = min(ncols, n)
+    nrows = int(np.ceil(n / ncols))
+    fig, axs = plt.subplots(nrows, ncols, figsize=(ncols * 1.4, nrows * 1.4))
+    axs = np.asarray(axs, dtype=object).ravel()
+    for i in range(len(axs)):
+        if i < n:
+            axs[i].imshow(arr[i], cmap=cmap)
+        axs[i].set_title("")
+    if title:
+        fig.suptitle(title)
+    return fig
+
+
+def plot_clusters_2d(X, labels, title="clusters", **kw):
+    """عناقيد 2D ملونة (KMeans/DBSCAN) — سريعة حتى 50k نقطة."""
+    plt = _plt()
+    X = np.asarray(X, dtype=float)
+    labels = np.asarray(labels).ravel()
+    for lab in sorted(np.unique(labels)):
+        m = labels == lab
+        plt.scatter(X[m, 0][:10000], X[m, 1][:10000], label=f"c{lab}")
+    plt.title(title)
+    plt.legend()
+    return plt.gca()

plotlibs/pyplot.py

@@ -0,0 +1,283 @@
+"""plotlibs.pyplot — matplotlib.pyplot-compatible state machine, faster."""
+from __future__ import annotations
+
+from . import style
+from .figure import Figure, subplots as _subplots
+
+_figures: dict[int, Figure] = {}
+_current: Figure | None = None
+_counter = [0]
+
+
+def _cur() -> Figure:
+    global _current
+    if _current is None:
+        _current = figure()
+    return _current
+
+
+def figure(figsize=None, dpi=None, facecolor=None, num=None):
+    global _current
+    _counter[0] += 1
+    n = num if num is not None else _counter[0]
+    fig = Figure(figsize=figsize, dpi=dpi, facecolor=facecolor, num=n)
+    _figures[n] = fig
+    _current = fig
+    return fig
+
+
+def gcf():
+    return _cur()
+
+
+def gca():
+    fig = _cur()
+    if not fig.axes:
+        return fig.add_subplot(1, 1, 1)
+    return fig.axes[-1]
+
+
+def subplots(nrows=1, ncols=1, figsize=None, dpi=None, **kw):
+    global _current
+    fig = Figure(figsize=figsize, dpi=dpi)
+    axs = fig.subplots(nrows, ncols)
+    _counter[0] += 1
+    _figures[_counter[0]] = fig
+    _current = fig
+    return fig, axs
+
+
+def subplot(nrows, ncols, index, **kw):
+    return _cur().add_subplot(nrows, ncols, index)
+
+
+def plot(*args, **kw):
+    return gca().plot(*args, **kw)
+
+
+def scatter(*args, **kw):
+    return gca().scatter(*args, **kw)
+
+
+def bar(*args, **kw):
+    return gca().bar(*args, **kw)
+
+
+def barh(*args, **kw):
+    return gca().barh(*args, **kw)
+
+
+def hist(*args, **kw):
+    return gca().hist(*args, **kw)
+
+
+def imshow(*args, **kw):
+    return gca().imshow(*args, **kw)
+
+
+def pie(*args, **kw):
+    return gca().pie(*args, **kw)
+
+
+def fill_between(*args, **kw):
+    return gca().fill_between(*args, **kw)
+
+
+def step(*args, **kw):
+    return gca().step(*args, **kw)
+
+
+def errorbar(*args, **kw):
+    return gca().errorbar(*args, **kw)
+
+
+def axhline(*args, **kw):
+    return gca().axhline(*args, **kw)
+
+
+def axvline(*args, **kw):
+    return gca().axvline(*args, **kw)
+
+
+def text(x, y, s, **kw):
+    return gca().text(x, y, s, **kw)
+
+
+def boxplot(*args, **kw):
+    return gca().boxplot(*args, **kw)
+
+
+def violinplot(*args, **kw):
+    return gca().violinplot(*args, **kw)
+
+
+def kde(*args, **kw):
+    return gca().kde(*args, **kw)
+
+
+density = kde
+
+
+def heatmap(*args, **kw):
+    return gca().heatmap(*args, **kw)
+
+
+def corr(*args, **kw):
+    return gca().corr(*args, **kw)
+
+
+def corrcoef(*args, **kw):
+    return gca().corr(*args, **kw)
+
+
+def countplot(*args, **kw):
+    return gca().countplot(*args, **kw)
+
+
+count = countplot
+
+
+def area(*args, **kw):
+    return gca().area(*args, **kw)
+
+
+stackplot = area
+
+
+def hist2d(*args, **kw):
+    return gca().hist2d(*args, **kw)
+
+
+def stem(*args, **kw):
+    return gca().stem(*args, **kw)
+
+
+def xlim(*args, **kw):
+    ax = gca()
+    if not args and not kw:
+        return ax.get_xlim()
+    if len(args) == 2:
+        return ax.set_xlim(args[0], args[1])
+    if len(args) == 1:
+        return ax.set_xlim(args[0][0], args[0][1])
+    left = kw.pop("left", None)
+    right = kw.pop("right", None)
+    return ax.set_xlim(left, right)
+
+
+def ylim(*args, **kw):
+    ax = gca()
+    if not args and not kw:
+        return ax.get_ylim()
+    if len(args) == 2:
+        return ax.set_ylim(args[0], args[1])
+    if len(args) == 1:
+        return ax.set_ylim(args[0][0], args[0][1])
+    bottom = kw.pop("bottom", None)
+    top = kw.pop("top", None)
+    return ax.set_ylim(bottom, top)
+
+
+def xlabel(s, **kw):
+    gca().set_xlabel(s)
+
+
+def ylabel(s, **kw):
+    gca().set_ylabel(s)
+
+
+def title(s, **kw):
+    gca().set_title(s)
+
+
+def suptitle(s, **kw):
+    _cur().suptitle(s)
+
+
+def legend(*args, **kw):
+    return gca().legend(*args, **kw)
+
+
+def grid(visible=True, **kw):
+    gca().grid(visible, **kw)
+
+
+def xticks(ticks=None, labels=None, **kw):
+    ax = gca()
+    if ticks is None:
+        from .fast import nice_ticks
+        xl = ax.get_xlim()
+        return nice_ticks(xl[0], xl[1]), None
+    ax.set_xticks(ticks)
+    return ticks, labels
+
+
+def yticks(ticks=None, labels=None, **kw):
+    ax = gca()
+    if ticks is None:
+        from .fast import nice_ticks
+        yl = ax.get_ylim()
+        return nice_ticks(yl[0], yl[1]), None
+    ax.set_yticks(ticks)
+    return ticks, labels
+
+
+def xscale(s, **kw):
+    gca().set_xscale(s)
+
+
+def yscale(s, **kw):
+    gca().set_yscale(s)
+
+
+def semilogx(*a, **k):
+    r = plot(*a, **k)
+    gca().set_xscale("log")
+    return r
+
+
+def semilogy(*a, **k):
+    r = plot(*a, **k)
+    gca().set_yscale("log")
+    return r
+
+
+def loglog(*a, **k):
+    r = plot(*a, **k)
+    gca().set_xscale("log")
+    gca().set_yscale("log")
+    return r
+
+
+def tight_layout(**kw):
+    _cur().tight_layout(**kw)
+
+
+def savefig(fname, dpi=None, **kw):
+    _cur().savefig(fname, dpi=dpi, **kw)
+
+
+def show(**kw):
+    _cur().show()
+
+
+def close(*args, **kw):
+    global _current
+    _figures.clear()
+    _current = None
+
+
+def clf():
+    _cur().clf()
+
+
+def cla():
+    gca().cla()
+
+
+def rcParams_update(d):
+    style.rcParams.update(d)
+
+
+rcParams = style.rcParams
+style_use = style.use

plotlibs/style.py

@@ -0,0 +1,96 @@
+"""plotlibs.style — rcParams + styles, matplotlib-compatible subset."""
+from __future__ import annotations
+
+rcParams: dict = {
+    "figure.figsize": (6.4, 4.8),
+    "figure.dpi": 100,
+    "figure.facecolor": "white",
+    "axes.facecolor": "white",
+    "axes.edgecolor": "black",
+    "axes.grid": False,
+    "axes.titlesize": 13,
+    "axes.labelsize": 11,
+    "xtick.labelsize": 9,
+    "ytick.labelsize": 9,
+    "font.size": 10,
+    "lines.linewidth": 1.8,
+    "lines.markersize": 6,
+    "savefig.dpi": 100,
+    "image.cmap": "viridis",
+}
+
+BRAND = {
+    "primary": "#4F46E5",
+    "accent": "#06B6D4",
+    "ink": "#0F172A",
+    "paper": "#F8FAFC",
+    "lime": "#A3E635",
+    "amber": "#FACC15",
+}
+
+_STYLES = {
+    "default": {},
+    "plotlibs": {"axes.facecolor": "white", "axes.grid": True,
+                 "figure.facecolor": "white", "axes.edgecolor": "#0F172A",
+                 "lines.linewidth": 2.2, "font.size": 11,
+                 "axes.labelsize": 11, "axes.titlesize": 13,
+                 "image.cmap": "viridis"},
+    "plotlibs-dark": {"figure.facecolor": "#0F172A", "axes.facecolor": "#1E293B",
+                      "axes.edgecolor": "white", "axes.grid": True,
+                      "lines.linewidth": 2.2, "font.size": 11},
+    "fast": {"axes.grid": True, "figure.dpi": 80},
+    "dark": {"figure.facecolor": "#1e1e1e", "axes.facecolor": "#1e1e1e",
+             "axes.edgecolor": "white", "axes.grid": True},
+    "ggplot": {"axes.facecolor": "#E5E5E5", "axes.grid": True,
+               "figure.facecolor": "#F5F5F5"},
+    "grayscale": {},
+    # extra gallery styles
+    "seaborn": {"axes.facecolor": "white", "axes.grid": True,
+                "figure.facecolor": "white", "lines.linewidth": 2.0,
+                "font.size": 11, "axes.labelsize": 11},
+    "seaborn-darkgrid": {"axes.facecolor": "#EAEAF2", "axes.grid": True,
+                         "figure.facecolor": "white", "axes.edgecolor": "white",
+                         "lines.linewidth": 2.0},
+    "plotly": {"axes.facecolor": "white", "axes.grid": True,
+               "figure.facecolor": "white", "lines.linewidth": 2.2,
+               "font.size": 12},
+    "publication": {"axes.facecolor": "white", "axes.grid": False,
+                    "figure.dpi": 150, "lines.linewidth": 1.5,
+                    "font.size": 10},
+    "darkgrid": {"figure.facecolor": "#212121", "axes.facecolor": "#2E2E2E",
+                 "axes.edgecolor": "white", "axes.grid": True},
+}
+
+_available_ = sorted(_STYLES)
+
+
+def use(name: str):
+    if name not in _STYLES:
+        raise ValueError(f"Unknown style {name!r}. Available: {_available_}")
+    base_face = rcParams.get("figure.facecolor", "white")
+    rcParams.update(_STYLES[name])
+    return base_face
+
+
+def available():
+    return list(_available_)
+
+
+class _StyleCtx:
+    def __init__(self, name):
+        self.name = name
+        self._saved = None
+
+    def __enter__(self):
+        self._saved = dict(rcParams)
+        use(self.name)
+        return self
+
+    def __exit__(self, *a):
+        rcParams.clear()
+        rcParams.update(self._saved)
+        return False
+
+
+def context(name: str):
+    return _StyleCtx(name)