Merge pull request #59 from ForgeOpus/claude/modelforge-notebook-cli-Zp0ef

Claude/modelforge notebook cli zp0ef

Author: RETR0-OS

ModelForge/cli.py

@@ -50,7 +50,31 @@ def check_huggingface_login():
 def main():
     """
     Main entry point for ModelForge CLI.
+
+    Subcommands:
+        modelforge        — start the web server
+        modelforge cli    — launch the interactive CLI wizard
     """
+    if len(sys.argv) > 1:
+        subcommand = sys.argv[1]
+        if subcommand == "cli":
+            try:
+                from .notebook_cli.wizard import main as cli_main
+            except ImportError as e:
+                logger.error(f"Failed to import CLI wizard or its dependencies: {e}")
+                print("\nThe interactive CLI requires optional dependencies that are not installed.")
+                print("Please install the CLI extras and try again, for example:")
+                print("  pip install \"modelforge-finetuning[cli]\"")
+                sys.exit(1)
+            cli_main()
+            return
+        else:
+            print(f"Unknown subcommand: '{subcommand}'")
+            print("Usage:")
+            print("  modelforge        Start the web server")
+            print("  modelforge cli    Launch the interactive CLI wizard")
+            sys.exit(1)
+
     print("\n" + "=" * 80)
     print("  __  __           _      _ _____                     ")
     print(" |  \\/  |         | |    | |  ___|                    ")

ModelForge/cli_old.py

@@ -87,9 +87,10 @@ def validate_dataset(
             if len(required_fields) > 0:
                 for i, example in enumerate(dataset.select(range(min(10, len(dataset))))):
                     for field in required_fields:
-                        if not example.get(field):
-                            logger.warning(
-                                f"Example {i} has empty field '{field}'"
+                        value = example.get(field)
+                        if value is None or (isinstance(value, str) and not value.strip()):
+                            raise DatasetValidationError(
+                                f"Example {i} has empty required field '{field}'."
                             )
 
             logger.info(

ModelForge/evaluation/dataset_validator.py

@@ -29,20 +29,27 @@ def compute_causal_lm_metrics(eval_pred: EvalPrediction) -> Dict[str, float]:
         """
         logger.info("Computing causal LM metrics")
 
+        import torch
+        import torch.nn.functional as F
+
         predictions, labels = eval_pred.predictions, eval_pred.label_ids
 
-        # For language modeling, predictions are logits
-        # Loss is computed by the trainer, we just calculate perplexity
-        if hasattr(eval_pred, 'loss') and eval_pred.loss is not None:
-            loss = eval_pred.loss
-        else:
-            # Fallback: estimate loss from predictions
-            loss = 0.0
+        logits = torch.from_numpy(np.array(predictions)).float()
+        lbl = torch.from_numpy(np.array(labels))
+
+        shift_logits = logits[..., :-1, :].contiguous()
+        shift_labels = lbl[..., 1:].contiguous()
 
-        perplexity = np.exp(loss) if loss > 0 else 0.0
+        loss = F.cross_entropy(
+            shift_logits.view(-1, shift_logits.size(-1)),
+            shift_labels.view(-1).long(),
+            ignore_index=-100,
+            reduction="mean",
+        )
+        perplexity = float(torch.exp(loss))
 
         metrics = {
-            "perplexity": float(perplexity),
+            "perplexity": perplexity,
             "eval_loss": float(loss),
         }
 
@@ -69,6 +76,9 @@ def compute_seq2seq_metrics(eval_pred: EvalPrediction, tokenizer: Any = None) ->
 
         predictions, labels = eval_pred.predictions, eval_pred.label_ids
 
+        if predictions.ndim == 3:
+            predictions = np.argmax(predictions, axis=-1)
+
         # Decode predictions and labels
         if tokenizer is not None:
             # Replace -100 in labels (used for padding)
@@ -88,9 +98,9 @@ def compute_seq2seq_metrics(eval_pred: EvalPrediction, tokenizer: Any = None) ->
                 )
 
                 metrics = {
-                    "rouge1": float(result["rouge1"].mid.fmeasure),
-                    "rouge2": float(result["rouge2"].mid.fmeasure),
-                    "rougeL": float(result["rougeL"].mid.fmeasure),
+                    "rouge1": float(result["rouge1"]),
+                    "rouge2": float(result["rouge2"]),
+                    "rougeL": float(result["rougeL"]),
                 }
 
                 logger.info(f"Seq2Seq metrics: {metrics}")

ModelForge/evaluation/metrics.py

@@ -0,0 +1,19 @@
+"""
+ModelForge Notebook CLI — public API.
+
+Provides an interactive wizard-style interface that calls the ModelForge
+Python APIs directly, without going through the REST/web layer.
+
+Install the required extras with:
+    pip install modelforge-finetuning[cli]
+
+Usage from a notebook cell:
+    from ModelForge.notebook_cli import run_cli
+    run_cli()
+
+Usage from a terminal:
+    modelforge-nb
+"""
+from .wizard import ModelForgeWizard, main as run_cli
+
+__all__ = ["ModelForgeWizard", "run_cli"]

ModelForge/notebook_cli/__init__.py

@@ -0,0 +1,127 @@
+"""
+Notebook-aware progress display for ModelForge CLI.
+
+Automatically uses ipywidgets when running inside a Jupyter/Colab/VSCode
+notebook environment, and falls back to tqdm for plain terminal use.
+"""
+from __future__ import annotations
+
+
+def _is_notebook() -> bool:
+    """Return True if running inside a Jupyter-compatible notebook kernel."""
+    try:
+        from IPython import get_ipython
+        shell = get_ipython()
+        if shell is None:
+            return False
+        return shell.__class__.__name__ == "ZMQInteractiveShell"
+    except ImportError:
+        return False
+
+
+class ProgressDisplay:
+    """
+    Unified progress display that works in notebooks and terminals.
+
+    Usage::
+
+        display = ProgressDisplay()
+        display.start("Loading model...")
+        display.update(50, "Halfway there")
+        display.update(100, "Done!")
+        display.close()
+    """
+
+    def __init__(self):
+        self._notebook = _is_notebook()
+        self._bar = None
+        self._label = None
+        self._tqdm_bar = None
+        self._last_value = 0
+
+    def start(self, message: str = "Starting...") -> None:
+        """Initialise and display the progress bar."""
+        self._last_value = 0
+        if self._notebook:
+            self._start_widget(message)
+        else:
+            self._start_tqdm(message)
+
+    def _start_widget(self, message: str) -> None:
+        try:
+            import ipywidgets as widgets
+            from IPython.display import display
+
+            self._bar = widgets.IntProgress(
+                value=0,
+                min=0,
+                max=100,
+                description="",
+                bar_style="info",
+                layout=widgets.Layout(width="100%"),
+            )
+            self._label = widgets.Label(value=message)
+            box = widgets.VBox([self._label, self._bar])
+            display(box)
+        except ImportError:
+            # ipywidgets not available — fall through to tqdm
+            self._notebook = False
+            self._start_tqdm(message)
+
+    def _start_tqdm(self, message: str) -> None:
+        from tqdm import tqdm
+
+        self._tqdm_bar = tqdm(
+            total=100,
+            desc=message,
+            bar_format="{desc}: {percentage:3.0f}%|{bar}| [{elapsed}]",
+            dynamic_ncols=True,
+        )
+
+    def update(self, value: int, message: str = "") -> None:
+        """
+        Update progress.
+
+        Args:
+            value: Progress value 0-100.
+            message: Status message to display alongside the bar.
+        """
+        value = max(0, min(100, value))
+        if self._notebook:
+            if self._bar is not None:
+                self._bar.value = value
+                if value >= 100:
+                    self._bar.bar_style = "success"
+            if self._label is not None and message:
+                self._label.value = message
+        else:
+            if self._tqdm_bar is not None:
+                delta = value - self._last_value
+                if delta > 0:
+                    self._tqdm_bar.update(delta)
+                if message:
+                    self._tqdm_bar.set_description(message)
+        self._last_value = value
+
+    def close(self) -> None:
+        """Close/finalize the progress display."""
+        if self._notebook:
+            if self._bar is not None:
+                self._bar.bar_style = "success"
+        else:
+            if self._tqdm_bar is not None:
+                self._tqdm_bar.close()
+                self._tqdm_bar = None
+
+    def error(self) -> None:
+        """Mark the progress bar as errored."""
+        if self._notebook:
+            if self._bar is not None:
+                self._bar.bar_style = "danger"
+            if self._label is not None:
+                self._label.value = "Training failed."
+        else:
+            if self._tqdm_bar is not None:
+                self._tqdm_bar.set_description("Training failed")
+                self._tqdm_bar.close()
+                self._tqdm_bar = None