epokio 0.3.0__py3-none-any.whl

epokio/__init__.py

@@ -0,0 +1,39 @@
+"""Epokio agent. 예전 이름은 TrainBar였다."""
+from __future__ import annotations
+
+from pathlib import Path
+
+# 판 번호는 여기 한 곳(pyproject가 이것을 읽는다). ★설치 정보로 읽어, 맥 앱(PYTHONPATH로 소스를 돌린다)과
+#   exe에서는 'unknown'이거나 따로 깔린 다른 epokio의 판이 나왔다
+__version__ = "0.3.0"
+
+
+def _migrate_home() -> None:
+    """옛 데이터 폴더 ~/.trainbar 를 ~/.epokio 로 한 번 옮긴다(새 폴더가 없을 때만).
+    기록 파일 안의 옛 경로도 새 경로로 고친다(대기열 결과 폴더, 알림함의 학습 위치)."""
+    old, new = Path.home() / ".trainbar", Path.home() / ".epokio"
+    if not old.is_dir() or new.exists():
+        return
+    try:
+        old.rename(new)
+        for f in new.glob("*.json"):
+            text = f.read_text(encoding="utf-8")
+            if "/.trainbar/" in text or "\\\\.trainbar\\\\" in text:
+                f.write_text(text.replace("/.trainbar/", "/.epokio/").replace("\\\\.trainbar\\\\", "\\\\.epokio\\\\"),
+                             encoding="utf-8")
+    except OSError:
+        pass            # 옮기지 못하면 새로 시작한다. 옛 폴더는 그대로 남는다
+
+
+_migrate_home()
+
+
+def version() -> str:
+    """이 코드의 판(맥 앱 판 build_app.sh와 같은 숫자로 맞춘다)"""
+    return __version__
+
+
+def start(folder, epochs=None, **params):
+    """직접 짠 학습 코드용 기록기: `run = epokio.start("runs/exp", epochs=50, lr=1e-4)` 후 `run.log(val_loss=..., acc=...)`"""
+    from .logger import start as _start
+    return _start(folder, epochs, **params)

epokio/__main__.py

@@ -0,0 +1,4 @@
+"""`python -m epokio setup` 처럼 쓴다. ★pip의 Scripts 폴더가 PATH에 없는 윈도우에서는 `epokio`가 '인식되지 않는 명령'이었다"""
+from .cli import main
+
+main()

epokio/adapters.py

@@ -0,0 +1,367 @@
+"""프레임워크별 학습 기록을 한 모양으로 바꾼다(어댑터).
+
+Epokio의 나머지 부분(목록·상태·곡선·해설·비교)은 "에폭별 행" 하나만 본다:
+    [{"epoch": "1", "time": "12.3", "train/xxx_loss": "...", "val/xxx_loss": "...", "metrics/xxx": "..."}, ...]
+값은 문자열이다(results.csv를 읽을 때와 같게). 열 이름 규칙:
+    손실  train/<이름>_loss · val/<이름>_loss      점수  metrics/<이름>   (높을수록 좋은 것만)
+
+새 프레임워크를 넣으려면 Adapter를 하나 더 만들어 ADAPTERS에 넣으면 된다.
+★코드를 고치지 않는다는 원칙: 프레임워크가 원래 남기는 파일만 읽는다.
+"""
+from __future__ import annotations
+
+import csv
+import json
+import math
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class Loaded:
+    framework: str
+    rows: list[dict]
+    source: Path                  # 갱신 시각을 잴 파일
+    total: int | None = None      # 계획 에폭
+    args: dict = field(default_factory=dict)
+    epoch: int | None = None      # 끝낸 에폭 수를 따로 아는 프레임워크(HF: 줄의 에폭은 평가 시점이라 다를 수 있다)
+
+
+def _num(v) -> str:
+    try:
+        x = float(v)
+    except (TypeError, ValueError):
+        return ""
+    if math.isnan(x):
+        return "nan"
+    return str(int(x)) if x.is_integer() and abs(x) < 1e15 else repr(x)
+
+
+def _read_csv(p: Path) -> list[dict]:
+    with p.open(encoding="utf-8", errors="ignore", newline="") as fh:
+        return [{(k or "").strip(): (v or "").strip() for k, v in r.items()} for r in csv.DictReader(fh)]
+
+
+def _yaml_value(text: str, key: str) -> str | None:
+    """한 줄짜리 'key: value'만 읽는다(yaml 의존성 없이)"""
+    m = re.search(rf"^\s*{re.escape(key)}\s*:\s*([^#\n]+)", text, re.M)
+    return m.group(1).strip() if m else None
+
+
+class Adapter:
+    name = ""
+
+    def detect(self, d: Path, names: set[str]) -> bool:
+        raise NotImplementedError
+
+    def load(self, d: Path) -> Loaded | None:
+        raise NotImplementedError
+
+
+class Ultralytics(Adapter):
+    """results.csv + args.yaml. 열 이름이 이미 규칙과 같다(train/box_loss, metrics/mAP50(B))."""
+    name = "ultralytics"
+
+    def detect(self, d, names):
+        return "results.csv" in names or "args.yaml" in names
+
+    def load(self, d):
+        p = d / "results.csv"
+        if not p.exists():
+            return None
+        rows = [r for r in _read_csv(p) if r.get("epoch")]
+        # epokio.start()로 기록한 직접 짠 학습은 'custom'. ★ultralytics로 보여서 "다시 학습" 등 YOLO 전용 기능이 붙었다
+        try:
+            custom = "task: custom" in (d / "args.yaml").read_text(encoding="utf-8", errors="ignore").splitlines()[:1]
+        except OSError:
+            custom = False
+        return Loaded("custom" if custom else self.name, rows, p)
+
+
+class HuggingFace(Adapter):
+    """transformers Trainer의 trainer_state.json (출력 폴더, 또는 가장 최근 checkpoint-N 안).
+    log_history에서 eval_* 기록이 나온 지점을 에폭 한 줄로 삼는다."""
+    name = "huggingface"
+    SKIP = {"eval_runtime", "eval_samples_per_second", "eval_steps_per_second", "epoch", "step", "eval_loss"}
+    # 점수가 아닌 것(시간·처리량·토큰 수). ★eval_model_preparation_time이 '대표 점수'로 뽑혔다
+    NOT_SCORE = re.compile(r"(_time|_runtime|_per_second|samples|num_tokens|^lr$|learning_rate)", re.IGNORECASE)
+
+    def _state(self, d: Path) -> Path | None:
+        if (d / "trainer_state.json").exists():
+            return d / "trainer_state.json"
+        cks = sorted(d.glob("checkpoint-*/trainer_state.json"), key=lambda p: int(re.sub(r"\D", "", p.parent.name) or 0))
+        return cks[-1] if cks else None
+
+    def detect(self, d, names):
+        return "trainer_state.json" in names or any(n.startswith("checkpoint-") for n in names if (d / n).is_dir()) \
+            and self._state(d) is not None
+
+    def load(self, d):
+        sp = self._state(d)
+        if not sp:
+            return None
+        try:
+            st = json.loads(sp.read_text(encoding="utf-8"))
+        except (OSError, ValueError):
+            return None
+        hist = st.get("log_history", [])
+        rows, last_train = [], None
+        for h in hist:
+            if "loss" in h:
+                last_train = h["loss"]
+            if "eval_loss" not in h and not any(k.startswith("eval_") for k in h):
+                continue
+            # 평가 시점의 에폭 그대로(0.25, 0.5…). ★올림(ceil)해서 첫 평가(0.1)에 1/1 '끝남'과 알림이 갔고,
+            #   한 에폭에 평가가 여러 번이면 마지막 것만 남아 곡선이 한 점이었다
+            ep = round(float(h.get("epoch") or len(rows) + 1), 3)
+            row = {"epoch": f"{ep:g}", "val/eval_loss": _num(h.get("eval_loss"))}
+            if last_train is not None:
+                row["train/train_loss"] = _num(last_train)
+            for k, v in h.items():
+                if k.startswith("eval_") and k not in self.SKIP and not self.NOT_SCORE.search(k[5:]) and isinstance(v, (int, float)):
+                    row[metric_column(k[5:], True)] = _num(v)
+            if rows and rows[-1]["epoch"] == row["epoch"]:
+                rows[-1] = row                       # 한 에폭에 평가가 여러 번이면 마지막 것
+            else:
+                rows.append(row)
+        if not rows and last_train is not None:      # 평가 없이 학습만: 손실만 보인다
+            rows = [{"epoch": f"{round(float(st.get('epoch') or 1), 3):g}", "train/train_loss": _num(last_train)}]
+        total = int(st["num_train_epochs"]) if st.get("num_train_epochs") else None
+        # 끝낸 에폭: 내림. 정해진 걸음(max_steps)을 다 갔으면 끝난 것
+        done = int(math.floor(float(st.get("epoch") or 0) + 1e-6))
+        if total and st.get("max_steps") and (st.get("global_step") or 0) >= st["max_steps"]:
+            done = max(done, total)
+        args = {k: str(st[k]) for k in ("num_train_epochs", "train_batch_size", "max_steps", "best_model_checkpoint") if st.get(k) is not None}
+        return Loaded(self.name, rows, sp, total, args, epoch=done)
+
+
+class Lightning(Adapter):
+    """PyTorch Lightning CSVLogger: lightning_logs/version_N/metrics.csv (+ hparams.yaml).
+    학습·검증 값이 서로 다른 줄에 흩어져 있어 에폭별로 모은다."""
+    name = "lightning"
+
+    def detect(self, d, names):
+        return "metrics.csv" in names and ("hparams.yaml" in names or d.name.startswith("version_"))
+
+    def load(self, d):
+        p = d / "metrics.csv"
+        try:
+            raw = _read_csv(p)
+        except OSError:
+            return None
+        by: dict[int, dict] = {}
+        for r in raw:
+            try:
+                ep = int(float(r.get("epoch", "")))
+            except ValueError:
+                continue
+            row = by.setdefault(ep, {"epoch": str(ep + 1)})       # Lightning 에폭은 0부터
+            for k, v in r.items():
+                # lr-Adam(LearningRateMonitor)은 점수가 아니다. ★최고 학습률이 '최고 점수'로 보였다
+                if k in ("epoch", "step") or v == "" or k.lower().startswith(("lr-", "lr_")) or k.lower() in ("lr", "learning_rate"):
+                    continue
+                row[self._name(k)] = v
+        rows = [by[k] for k in sorted(by)]
+        total = None
+        if (d / "hparams.yaml").exists():
+            t = (d / "hparams.yaml").read_text(encoding="utf-8", errors="ignore")
+            v = _yaml_value(t, "max_epochs") or _yaml_value(t, "epochs")
+            total = int(float(v)) if v and v.replace(".", "").isdigit() else None
+        return Loaded(self.name, rows, p, total)
+
+    @staticmethod
+    def _name(k: str) -> str:
+        k = k.replace("_epoch", "").replace("/", "_")
+        if "loss" in k:
+            side = "val" if k.startswith(("val", "valid")) else "train"
+            return f"{side}/{k if k.endswith('_loss') else k + '_loss'}"
+        return metric_column(k, k.startswith(("val", "valid")))
+
+
+class Keras(Adapter):
+    """Keras CSVLogger. 파일 이름은 사용자가 정하므로 흔한 이름만 본다(training.log, history.csv, *keras*.csv)."""
+    name = "keras"
+    FILES = ("training.log", "history.csv", "training.csv", "keras_log.csv")
+
+    def _file(self, d: Path, names: set[str]) -> Path | None:
+        for n in self.FILES:
+            if n in names:
+                return d / n
+        for n in names:
+            if n.endswith(".csv") and "keras" in n.lower():
+                return d / n
+        return None
+
+    def detect(self, d, names):
+        f = self._file(d, names)
+        if not f:
+            return False
+        try:
+            head = f.open(encoding="utf-8", errors="ignore").readline().lower()
+        except OSError:
+            return False
+        return head.startswith("epoch") and "loss" in head
+
+    def load(self, d):
+        f = self._file(d, {p.name for p in d.iterdir()})
+        if not f:
+            return None
+        rows = []
+        for r in _read_csv(f):
+            try:
+                ep = int(float(r["epoch"])) + 1                    # Keras 에폭은 0부터
+            except (KeyError, ValueError):
+                continue
+            row = {"epoch": str(ep)}
+            for k, v in r.items():
+                if k == "epoch":
+                    continue
+                if k in ("loss", "val_loss"):
+                    row["val/val_loss" if k == "val_loss" else "train/train_loss"] = v
+                elif k.endswith("loss"):
+                    row[("val/" if k.startswith("val_") else "train/") + k] = v
+                elif k in ("lr", "learning_rate"):
+                    continue
+                else:
+                    row[metric_column(k, k.startswith("val_"))] = v
+            rows.append(row)
+        return Loaded(self.name, rows, f)
+
+
+class TensorBoard(Adapter):
+    """TensorBoard 이벤트 파일. Lightning의 기본 기록기(lightning_logs/version_N)와 trainer_state.json을 남기지 않은
+    Hugging Face 학습(<출력>/runs/<날짜_기계>)이 이것만 남긴다. ★예전엔 이런 학습이 목록에 아예 안 보였다.
+    검증 값이 찍힌 걸음마다 한 줄을 만들고, 그때까지의 학습 값을 함께 싣는다."""
+    name = "tensorboard"
+    # 점수가 아닌 것. 에폭 태그 자체(epoch·train/epoch)는 따로 쓴다(★train_loss_epoch 같은 에폭 평균까지 빼면 안 된다)
+    NOT_SCORE = re.compile(r"(^|[/_])(lr|learning_rate|grad_norm|hp_metric)($|[/_-])|_time$|runtime|per_second|"
+                           r"samples|num_tokens|flos", re.IGNORECASE)
+
+    @staticmethod
+    def _files(d: Path) -> list[Path]:
+        return sorted(p for p in d.iterdir() if p.name.startswith("events.out.tfevents."))
+
+    @classmethod
+    def _keras(cls, d: Path, names) -> bool:
+        """Keras TensorBoard 콜백: <log_dir>/train 과 <log_dir>/validation 에 따로 쓴다.
+        ★둘이 다른 학습 두 개로 보였고, 검증 손실이 train/epoch_loss로 들어갔다"""
+        try:
+            return {"train", "validation"} <= set(names) and all(cls._files(d / s) for s in ("train", "validation"))
+        except OSError:
+            return False
+
+    def detect(self, d, names):
+        if self._keras(d, names):
+            return True
+        if not any(n.startswith("events.out.tfevents.") for n in names):
+            return False
+        # HF 출력 폴더에 trainer_state.json이 있으면 그쪽(HuggingFace)이 읽는다. 같은 학습이 두 번 보이지 않게
+        out = d.parent.parent if d.parent.name == "runs" else None
+        return not (out and ((out / "trainer_state.json").exists() or any(out.glob("checkpoint-*/trainer_state.json"))))
+
+    @staticmethod
+    def _column(tag: str) -> str:
+        key = tag.replace("/", "_")
+        if key.lower().startswith("eval_"):
+            key = "val_" + key[5:]
+        key = re.sub(r"_epoch$", "", key)
+        val = key.lower().startswith(("val", "valid", "test"))
+        if "loss" in key.lower():
+            return f"{'val' if val else 'train'}/{key if key.endswith('_loss') else key + '_loss'}"
+        return metric_column(key, val)
+
+    def load(self, d):
+        from . import tfevents
+        keras = self._keras(d, {p.name for p in d.iterdir()})
+        # Keras는 폴더가 곧 쪽이다(train/validation). 태그 epoch_loss → train_loss·val_loss
+        parts = [(d / "train", "train_"), (d / "validation", "val_")] if keras else [(d, "")]
+        files = [(f, pre) for sub, pre in parts for f in self._files(sub)]
+        if not files:
+            return None
+        scalars: dict[int, dict[str, float]] = {}
+        walls: dict[int, float] = {}
+        for f, pre in files:                              # 다시 시작하면 파일이 하나 더 생긴다
+            sc, wl = tfevents.read(f)
+            for step, vals in sc.items():
+                if pre:
+                    vals = {pre + re.sub(r"^epoch_", "", k): v for k, v in vals.items() if k.startswith("epoch_")}
+                scalars.setdefault(step, {}).update(vals)
+            for step, w in wl.items():
+                walls.setdefault(step, w)
+        if not scalars:
+            return None
+        tags = {t for v in scalars.values() for t in v}
+        hf = "train/epoch" in tags
+        etag = "train/epoch" if hf else "epoch" if "epoch" in tags else None
+        is_val = lambda t: t.lower().startswith(("val", "eval", "valid", "test"))
+        keep = {t: self._column(t) for t in tags
+                if t not in ("epoch", "train/epoch") and not self.NOT_SCORE.search(t.lower()) and not t.endswith("_step")}
+        steps = sorted(scalars)
+        marks = [s for s in steps if any(is_val(t) for t in scalars[s])] or steps
+        if len(marks) > 2000:                            # 평가가 없고 걸음이 아주 많으면 고르게 줄인다
+            k = len(marks) / 2000
+            marks = [marks[int(i * k)] for i in range(2000)] + [marks[-1]]
+        want, rows, latest, ep, t0, j = set(marks), [], {}, None, min(walls.values(), default=None), 0
+        for s in steps:
+            vals = scalars[s]
+            if etag in vals:
+                ep = vals[etag]
+            latest.update(vals)
+            if s not in want:
+                continue
+            j += 1
+            if keras:
+                e = s + 1                                  # Keras는 걸음이 곧 에폭(0부터)
+            else:
+                e = (round(ep, 3) if hf else int(ep) + 1) if ep is not None else j     # Lightning 에폭은 0부터
+            row = {"epoch": f"{e:g}"}
+            if t0 is not None and s in walls:
+                row["time"] = f"{walls[s] - t0:.1f}"
+            for t, col in keep.items():
+                if t in latest:
+                    row[col] = _num(latest[t])
+            if rows and rows[-1]["epoch"] == row["epoch"]:
+                rows[-1] = row
+            else:
+                rows.append(row)
+        total = None
+        if (d / "hparams.yaml").exists():
+            t = (d / "hparams.yaml").read_text(encoding="utf-8", errors="ignore")
+            v = _yaml_value(t, "max_epochs") or _yaml_value(t, "num_train_epochs") or _yaml_value(t, "epochs")
+            total = int(float(v)) if v and v.replace(".", "").isdigit() else None
+        done = int(math.floor(ep + 1e-6)) if hf and ep is not None else None
+        return Loaded(self.name, rows, max((f for f, _ in files), key=lambda f: f.stat().st_mtime), total, epoch=done)
+
+
+ADAPTERS: list[Adapter] = [Ultralytics(), HuggingFace(), Lightning(), Keras(), TensorBoard()]
+
+# 낮을수록 좋은 지표. metrics/ 는 '높을수록 좋은 것만'이라는 규칙이라 손실 쪽으로 보낸다.
+# ★mae·rmse를 metrics/ 로 두었더니 최고점 고르기가 가장 나쁜 에폭을 'best'로 골랐다(Keras 회귀 모델)
+# ★crossentropy 같은 손실을 metrics로 받은 Keras에서 가장 나쁜 에폭을 best로 골랐다
+_LOWER = re.compile(r"(^|_)(mae|mse|rmse|msle|mape|error|err|perplexity|wer|cer|loss|crossentropy|hinge|kl|"
+                    r"kld|divergence|poisson|logcosh|nll)($|_)", re.IGNORECASE)
+
+
+def metric_column(key: str, val_side: bool) -> str:
+    return f"{'val' if val_side else 'train'}/{key}_loss" if _LOWER.search(key) else f"metrics/{key}"
+
+
+def detect(d: Path, names: set[str] | None = None) -> Adapter | None:
+    if names is None:
+        try:
+            names = {p.name for p in d.iterdir()}
+        except OSError:
+            return None
+    for a in ADAPTERS:
+        try:
+            if a.detect(d, names):
+                return a
+        except OSError:
+            continue
+    return None
+
+
+def load(d: Path) -> Loaded | None:
+    a = detect(d)
+    return a.load(d) if a else None