morphlog-vp 1.0.0__tar.gz

morphlog_vp-1.0.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: morphlog-vp
+Version: 1.0.0
+Summary: Structured training logger with per-expert loss display.
+Author: F000NK, Voluntas Progressus
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.14
+Requires-Dist: vpterm-vp>=1.0.0

morphlog_vp-1.0.0/morphlog/__init__.py

@@ -0,0 +1,9 @@
+"""Structured training logger with per-expert loss display.
+
+Uses vpterm for beautiful terminal rendering.
+"""
+
+from morphlog.train_logger import TrainLogger
+from morphlog.formatters import format_loss_breakdown, format_expert_losses
+
+__version__ = "1.0.0"

morphlog_vp-1.0.0/morphlog/formatters.py

@@ -0,0 +1,84 @@
+"""Formatting helpers for training metrics and per-expert losses."""
+
+from __future__ import annotations
+
+from vpterm.style import Style
+
+
+def format_loss_value(value: float, precision: int = 4) -> str:
+    """Format a loss value with color coding based on magnitude."""
+    formatted = f"{value:.{precision}f}"
+    if value > 10.0:
+        return Style.bright_red(formatted)
+    if value > 5.0:
+        return Style.yellow(formatted)
+    if value > 1.0:
+        return Style.bright_yellow(formatted)
+    return Style.bright_green(formatted)
+
+
+def format_loss_breakdown(losses: dict[str, float], precision: int = 4) -> str:
+    """Format a flat loss dict into a human-readable string.
+
+    Supports keys like 'total', 'final', 'universal', 'family/slavic',
+    'language/rus', etc.
+
+    Returns a multi-line string with grouped losses.
+    """
+    lines: list[str] = []
+
+    total = losses.get("total")
+    final = losses.get("final")
+    if total is not None:
+        parts = [f"  {Style.metric_name('total')}{Style.dim('=')}{format_loss_value(total, precision)}"]
+        if final is not None:
+            parts.append(f"{Style.metric_name('final')}{Style.dim('=')}{format_loss_value(final, precision)}")
+        lines.append("  ".join(parts))
+
+    universal = losses.get("universal")
+    if universal is not None:
+        lines.append(f"  {Style.metric_name('universal')}{Style.dim('=')}{format_loss_value(universal, precision)}")
+
+    family_losses = {key: value for key, value in losses.items() if key.startswith("family/")}
+    if family_losses:
+        parts = [f"  {Style.cyan('family')}  "]
+        for key, value in sorted(family_losses.items()):
+            expert_name = key.split("/", 1)[1]
+            parts.append(f"{Style.label(expert_name)}{Style.dim('=')}{format_loss_value(value, precision)}")
+        lines.append("  ".join(parts))
+
+    language_losses = {key: value for key, value in losses.items() if key.startswith("language/")}
+    if language_losses:
+        parts = [f"  {Style.cyan('language')}"]
+        for key, value in sorted(language_losses.items()):
+            expert_name = key.split("/", 1)[1]
+            parts.append(f"{Style.label(expert_name)}{Style.dim('=')}{format_loss_value(value, precision)}")
+        lines.append("  ".join(parts))
+
+    return "\n".join(lines)
+
+
+def format_expert_losses(expert_losses: dict[str, float], precision: int = 4) -> str:
+    """Format per-expert losses as a single line for compact display.
+
+    Args:
+        expert_losses: Dict like {"slavic": 5.12, "romance": 5.83}.
+        precision: Decimal places.
+    """
+    parts = []
+    for name, value in sorted(expert_losses.items()):
+        parts.append(f"{Style.label(name)}{Style.dim('=')}{format_loss_value(value, precision)}")
+    return "  ".join(parts)
+
+
+def format_lr(learning_rate: float) -> str:
+    """Format learning rate with scientific notation coloring."""
+    return Style.metric_value(f"{learning_rate:.2e}")
+
+
+def format_improvement(current: float, best: float) -> str:
+    """Format a value showing improvement or degradation vs best."""
+    formatted = f"{current:.4f}"
+    if current <= best:
+        return Style.improved(f"{formatted} ★")
+    return format_loss_value(current)

morphlog_vp-1.0.0/morphlog/train_logger.py

@@ -0,0 +1,296 @@
+"""Training logger — structured output for CELMoE training loops.
+
+Provides:
+- Training header with model/data summary
+- Per-batch progress with per-expert loss breakdown
+- Epoch summaries with dev evaluation
+- Beautiful formatting via vpterm
+"""
+
+from __future__ import annotations
+
+import math
+
+from vpterm.style import Style
+from vpterm.panel import Panel
+from vpterm.progress import ProgressBar, format_duration, format_number
+from vpterm.terminal import Terminal, get_terminal
+from vpterm.kv import KeyValue
+
+from morphlog.formatters import format_loss_value, format_lr, format_improvement
+
+
+class TrainLogger:
+    """Structured logger for CELMoE training sessions.
+
+    Usage:
+        logger = TrainLogger()
+        logger.training_header(...)
+        logger.batch_update(...)
+        logger.epoch_summary(...)
+    """
+
+    def __init__(self, terminal: Terminal | None = None) -> None:
+        self.terminal = terminal or get_terminal()
+
+    def training_header(
+        self,
+        *,
+        version: str,
+        model_family: str,
+        model_series: str,
+        stage: str,
+        device: str,
+        amp: bool,
+        train_rows: int,
+        dev_rows: int,
+        num_languages: int,
+        num_families: int,
+        families: list[str],
+        languages: list[str],
+        max_len: int,
+        max_features: int,
+        d_model: int,
+        dim_ff: int,
+        num_heads: int,
+        num_kv_heads: int,
+        universal_layers: int,
+        family_layers: int,
+        language_layers: int,
+        total_params: int,
+        trainable_params: int,
+        epochs: int,
+        batch_size: int,
+        train_batches: int,
+        dev_batches: int,
+        total_steps: int,
+        warmup_steps: int,
+        lr: float,
+        weight_decay: float,
+        betas: tuple[float, float],
+        output_dir: str,
+        loss_weights: dict[str, float],
+    ) -> None:
+        """Print full training configuration header."""
+        panel = Panel(title=f"MorphFormer {model_series} — CELMoE Training")
+
+        panel.add_section("Run")
+        panel.add_kv("version", version)
+        panel.add_kv("stage", Style.bold(stage))
+        panel.add_kv("device", f"{device}  {'AMP' if amp else 'FP32'}")
+        panel.add_kv("output", output_dir)
+
+        panel.add_blank()
+        panel.add_section("Data")
+        panel.add_kv("train", f"{format_number(train_rows)} rows")
+        panel.add_kv("dev", f"{format_number(dev_rows)} rows")
+        panel.add_kv("languages", f"{num_languages}  {Style.dim(' '.join(languages))}")
+        panel.add_kv("families", f"{num_families}  {Style.dim(' '.join(families))}")
+        panel.add_kv("max length", str(max_len))
+        panel.add_kv("max features", str(max_features))
+
+        panel.add_blank()
+        panel.add_section("Model")
+        panel.add_kv("d_model", str(d_model))
+        panel.add_kv("dim_ff", str(dim_ff))
+        panel.add_kv("heads", f"{num_heads} query  {num_kv_heads} kv")
+        panel.add_kv("layers", f"{universal_layers} universal  {family_layers} family  {language_layers} language")
+        panel.add_kv("parameters", f"{format_number(total_params)} total  {format_number(trainable_params)} trainable")
+
+        panel.add_blank()
+        panel.add_section("Training")
+        panel.add_kv("epochs", str(epochs))
+        panel.add_kv("batch size", str(batch_size))
+        panel.add_kv("batches", f"{format_number(train_batches)} train  {format_number(dev_batches)} dev")
+        panel.add_kv("steps", f"{format_number(total_steps)} total  {format_number(warmup_steps)} warmup")
+
+        panel.add_blank()
+        panel.add_section("Optimizer")
+        panel.add_kv("lr", str(lr))
+        panel.add_kv("weight decay", str(weight_decay))
+        panel.add_kv("betas", str(list(betas)))
+
+        panel.add_blank()
+        panel.add_section("Loss Weights")
+        for name, weight in sorted(loss_weights.items()):
+            panel.add_kv(name, f"{weight:.2f}")
+
+        self.terminal.writeln(panel.render())
+        self.terminal.blank_line()
+
+    def epoch_start(self, epoch: int, total_epochs: int, train_batches: int, dev_batches: int) -> None:
+        """Log epoch start."""
+        self.terminal.header(f"Epoch {epoch}/{total_epochs}")
+        self.terminal.writeln(
+            f"  {Style.dim('train')} {format_number(train_batches)} batches  "
+            f"{Style.dim('dev')} {format_number(dev_batches)} batches"
+        )
+
+    def batch_update(
+        self,
+        *,
+        epoch: int,
+        total_epochs: int,
+        batch: int,
+        total_batches: int,
+        step: int,
+        total_steps: int,
+        learning_rate: float,
+        losses: dict[str, float],
+        elapsed_seconds: float,
+        total_completed_batches: int,
+        total_train_batches: int,
+        best_dev_loss: float,
+    ) -> None:
+        """Log a training batch update with per-expert losses.
+
+        Args:
+            losses: Dict with keys like 'total', 'final', 'universal',
+                    'family/slavic', 'language/rus', etc.
+        """
+        seconds_per_batch = elapsed_seconds / max(1, total_completed_batches)
+        remaining_batches = max(0, total_train_batches - total_completed_batches)
+        remaining_seconds = seconds_per_batch * remaining_batches
+
+        progress = ProgressBar(total=total_batches, width=20)
+        progress_line = f"  {progress.render_with_label(batch, 'progress')}"
+
+        line = KeyValue(separator="  ")
+        line.add("epoch", f"{epoch}/{total_epochs}")
+        line.add("batch", f"{batch}/{total_batches}")
+        line.add("step", f"{step}/{total_steps}")
+        line.add_raw(f"{Style.metric_name('lr')}{Style.dim('=')}{format_lr(learning_rate)}")
+
+        main_line = line.render()
+
+        loss_parts: list[str] = []
+        total_loss = losses.get("total")
+        final_loss = losses.get("final")
+        universal_loss = losses.get("universal")
+        if total_loss is not None:
+            loss_parts.append(f"{Style.metric_name('loss')}{Style.dim('=')}{format_loss_value(total_loss)}")
+        if final_loss is not None:
+            loss_parts.append(f"{Style.metric_name('final')}{Style.dim('=')}{format_loss_value(final_loss)}")
+        if universal_loss is not None:
+            loss_parts.append(f"{Style.metric_name('universal')}{Style.dim('=')}{format_loss_value(universal_loss)}")
+        loss_line = "  ".join(loss_parts)
+
+        family_losses = {key: val for key, val in sorted(losses.items()) if key.startswith("family/")}
+        language_losses = {key: val for key, val in sorted(losses.items()) if key.startswith("language/")}
+
+        family_line = ""
+        if family_losses:
+            family_parts = [f"  {Style.cyan('family')}  "]
+            for key, val in family_losses.items():
+                expert_name = key.split("/", 1)[1]
+                family_parts.append(f"{Style.label(expert_name)}{Style.dim('=')}{format_loss_value(val)}")
+            family_line = " ".join(family_parts)
+
+        language_line = ""
+        if language_losses:
+            lang_parts = [f"  {Style.cyan('language')}"]
+            for key, val in language_losses.items():
+                expert_name = key.split("/", 1)[1]
+                lang_parts.append(f"{Style.label(expert_name)}{Style.dim('=')}{format_loss_value(val)}")
+            language_line = " ".join(lang_parts)
+
+        best_display = "n/a" if math.isinf(best_dev_loss) else f"{best_dev_loss:.4f}"
+        time_line = (
+            f"  {Style.dim('elapsed')}{Style.dim('=')}{Style.timestamp(format_duration(elapsed_seconds))}"
+            f"  {Style.dim('remaining')}{Style.dim('=')}{Style.timestamp(format_duration(remaining_seconds))}"
+            f"  {Style.dim('best dev')}{Style.dim('=')}{Style.metric_value(best_display)}"
+        )
+
+        output = f"  {main_line}\n  {loss_line}"
+        output += f"\n{progress_line}"
+        if family_line:
+            output += f"\n{family_line}"
+        if language_line:
+            output += f"\n{language_line}"
+        output += f"\n{time_line}"
+
+        self.terminal.writeln(output)
+
+    def epoch_end(
+        self,
+        *,
+        epoch: int,
+        total_epochs: int,
+        dev_loss: float,
+        best_dev_loss: float,
+        improved: bool,
+        epoch_elapsed: float,
+        total_elapsed: float,
+        remaining_seconds: float,
+        checkpoint_path: str | None,
+        dev_expert_losses: dict[str, float] | None = None,
+    ) -> None:
+        """Log epoch completion with dev evaluation results."""
+        self.terminal.blank_line()
+
+        status_icon = Style.success("✓") if improved else Style.dim("·")
+        dev_display = format_improvement(dev_loss, best_dev_loss) if improved else format_loss_value(dev_loss)
+        best_display = format_loss_value(best_dev_loss)
+
+        self.terminal.writeln(
+            f" {status_icon} {Style.bold(f'Epoch {epoch}/{total_epochs}')} "
+            f" {Style.dim('dev loss')}{Style.dim('=')}{dev_display}"
+            f"  {Style.dim('best')}{Style.dim('=')}{best_display}"
+            f"  {Style.dim('epoch time')}{Style.dim('=')}{Style.timestamp(format_duration(epoch_elapsed))}"
+            f"  {Style.dim('elapsed')}{Style.dim('=')}{Style.timestamp(format_duration(total_elapsed))}"
+            f"  {Style.dim('remaining')}{Style.dim('=')}{Style.timestamp(format_duration(remaining_seconds))}"
+        )
+
+        if dev_expert_losses:
+            family_losses = {k: v for k, v in dev_expert_losses.items() if k.startswith("family/")}
+            language_losses = {k: v for k, v in dev_expert_losses.items() if k.startswith("language/")}
+            if family_losses:
+                parts = [f"   {Style.cyan('dev family')}  "]
+                for key, val in sorted(family_losses.items()):
+                    name = key.split("/", 1)[1]
+                    parts.append(f"{Style.label(name)}{Style.dim('=')}{format_loss_value(val)}")
+                self.terminal.writeln(" ".join(parts))
+            if language_losses:
+                parts = [f"   {Style.cyan('dev language')}"]
+                for key, val in sorted(language_losses.items()):
+                    name = key.split("/", 1)[1]
+                    parts.append(f"{Style.label(name)}{Style.dim('=')}{format_loss_value(val)}")
+                self.terminal.writeln(" ".join(parts))
+
+        if checkpoint_path:
+            self.terminal.writeln(f"   {Style.dim('checkpoint')} {Style.green(checkpoint_path)}")
+
+        self.terminal.blank_line()
+
+    def training_interrupted(
+        self,
+        epoch: int,
+        total_epochs: int,
+        batch: int,
+        total_batches: int,
+        step: int,
+        total_steps: int,
+        elapsed_seconds: float,
+        checkpoint_path: str,
+    ) -> None:
+        """Log training interruption."""
+        self.terminal.blank_line()
+        self.terminal.writeln(
+            f" {Style.warning('■')} {Style.bold('Training interrupted')}"
+            f"  epoch={epoch}/{total_epochs}  batch={batch}/{total_batches}"
+            f"  step={step}/{total_steps}"
+            f"  elapsed={Style.timestamp(format_duration(elapsed_seconds))}"
+        )
+        self.terminal.writeln(f"   {Style.dim('checkpoint')} {Style.yellow(checkpoint_path)}")
+        self.terminal.blank_line()
+
+    def training_complete(self, best_path: str, best_dev_loss: float, total_elapsed: float) -> None:
+        """Log training completion."""
+        self.terminal.blank_line()
+        self.terminal.writeln(
+            f" {Style.success('✓')} {Style.bold('Training complete')}"
+            f"  best dev={Style.improved(f'{best_dev_loss:.4f}')}"
+            f"  time={Style.timestamp(format_duration(total_elapsed))}"
+        )
+        self.terminal.writeln(f"   {Style.dim('best checkpoint')} {Style.green(best_path)}")
+        self.terminal.blank_line()

morphlog_vp-1.0.0/morphlog_vp.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: morphlog-vp
+Version: 1.0.0
+Summary: Structured training logger with per-expert loss display.
+Author: F000NK, Voluntas Progressus
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.14
+Requires-Dist: vpterm-vp>=1.0.0

morphlog_vp-1.0.0/morphlog_vp.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+pyproject.toml
+morphlog/__init__.py
+morphlog/formatters.py
+morphlog/py.typed
+morphlog/train_logger.py
+morphlog_vp.egg-info/PKG-INFO
+morphlog_vp.egg-info/SOURCES.txt
+morphlog_vp.egg-info/dependency_links.txt
+morphlog_vp.egg-info/requires.txt
+morphlog_vp.egg-info/top_level.txt

morphlog_vp-1.0.0/morphlog_vp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

morphlog_vp-1.0.0/morphlog_vp.egg-info/requires.txt

@@ -0,0 +1 @@
+vpterm-vp>=1.0.0

morphlog_vp-1.0.0/morphlog_vp.egg-info/top_level.txt

@@ -0,0 +1 @@
+morphlog

morphlog_vp-1.0.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=69.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "morphlog-vp"
+version = "1.0.0"
+authors = [
+    { name = "F000NK" },
+    { name = "Voluntas Progressus" },
+]
+description = "Structured training logger with per-expert loss display."
+license = "MIT"
+requires-python = ">=3.14"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.14",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "vpterm-vp>=1.0.0",
+]
+
+[tool.setuptools.packages.find]
+include = ["morphlog*"]
+
+[tool.setuptools.package-data]
+morphlog = ["py.typed"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py314"

morphlog_vp-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+