modelforge-finetuning 3.0.1__tar.gz → 3.0.2__tar.gz

{modelforge_finetuning-3.0.1 → modelforge_finetuning-3.0.2}/ModelForge/formatters/formatting_functions.py

@@ -6,10 +6,23 @@ that are ready for training. Each function must return a list of strings
 as required by Unsloth.
 """
 
-from typing import Callable, List
+from typing import Any, Callable, List, Optional
 
+try:
+    from jinja2.exceptions import TemplateError
+except ImportError:
+    TemplateError = Exception
 
-def create_text_generation_formatter(eos_token: str) -> Callable:
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def create_text_generation_formatter(
+    eos_token: str,
+    tokenizer: Optional[Any] = None,
+    use_chat_template: bool = False,
+) -> Callable:
     """
     Create formatting function for text-generation tasks.
 
@@ -19,6 +32,8 @@ def create_text_generation_formatter(eos_token: str) -> Callable:
 
     Args:
         eos_token: The EOS token string from the tokenizer
+        tokenizer: Optional tokenizer instance (required when use_chat_template=True)
+        use_chat_template: If True, use the tokenizer's native chat template
 
     Returns:
         Formatting function that returns a list of formatted strings
@@ -27,9 +42,24 @@ def create_text_generation_formatter(eos_token: str) -> Callable:
         prompt = example.get("prompt", "")
         completion = example.get("completion", "")
 
-        # Format as USER/ASSISTANT conversation with EOS token
+        if use_chat_template and tokenizer is not None:
+            try:
+                messages = [
+                    {"role": "user", "content": prompt},
+                    {"role": "assistant", "content": completion},
+                ]
+                text = tokenizer.apply_chat_template(
+                    messages, tokenize=False, add_generation_prompt=False
+                )
+                return [text]
+            except (AttributeError, TemplateError, Exception) as e:
+                logger.warning(
+                    f"Chat template unavailable ({e}), "
+                    f"falling back to USER/ASSISTANT format"
+                )
+
+        # Default: USER/ASSISTANT conversation with EOS token
         text = f"USER: {prompt}\nASSISTANT: {completion}{eos_token}"
-
         return [text]  # Must return list as required by Unsloth
 
     return formatting_func
@@ -95,13 +125,20 @@ def create_qa_formatter(eos_token: str) -> Callable:
     return formatting_func
 
 
-def get_formatting_func(task: str, eos_token: str) -> Callable:
+def get_formatting_func(
+    task: str,
+    eos_token: str,
+    tokenizer: Optional[Any] = None,
+    use_chat_template: bool = False,
+) -> Callable:
     """
     Get the appropriate formatting function for a given task type.
 
     Args:
         task: Task type (e.g., "text-generation", "summarization", "extractive-question-answering")
         eos_token: The EOS token string from the tokenizer
+        tokenizer: Optional tokenizer instance (used when use_chat_template=True)
+        use_chat_template: If True, use the tokenizer's native chat template for text-generation
 
     Returns:
         Formatting function for the specified task
@@ -109,8 +146,12 @@ def get_formatting_func(task: str, eos_token: str) -> Callable:
     Raises:
         ValueError: If the task type is not supported
     """
+    if task == "text-generation":
+        return create_text_generation_formatter(
+            eos_token, tokenizer=tokenizer, use_chat_template=use_chat_template
+        )
+
     formatters = {
-        "text-generation": create_text_generation_formatter,
         "summarization": create_summarization_formatter,
         "extractive-question-answering": create_qa_formatter,
     }
@@ -119,7 +160,7 @@ def get_formatting_func(task: str, eos_token: str) -> Callable:
     if formatter_creator is None:
         raise ValueError(
             f"No formatter available for task: {task}. "
-            f"Supported tasks: {list(formatters.keys())}"
+            f"Supported tasks: ['text-generation', {', '.join(repr(k) for k in formatters)}]"
         )
 
     return formatter_creator(eos_token)

{modelforge_finetuning-3.0.1 → modelforge_finetuning-3.0.2}/ModelForge/notebook_cli/prompts.py

@@ -2,7 +2,8 @@
 Interactive prompt steps for the ModelForge notebook CLI wizard.
 
 Each function handles one wizard step and returns a typed value.
-All prompts use questionary; display panels use rich.
+Uses questionary in terminals; falls back to plain input() in notebooks.
+Display panels use rich.
 """
 from __future__ import annotations
 
@@ -19,6 +20,67 @@ if TYPE_CHECKING:
 
 console = Console()
 
+
+def _is_notebook() -> bool:
+    """Return True when running inside a Jupyter/Colab/Databricks kernel."""
+    try:
+        from IPython import get_ipython
+        return get_ipython() is not None
+    except ImportError:
+        return False
+
+
+_IN_NOTEBOOK = _is_notebook()
+
+
+# ── Notebook-safe input() fallbacks ──────────────────────────────────────────
+
+def _nb_select(message: str, choices: list) -> str:
+    """Numbered-menu fallback for questionary.select()."""
+    print(f"\n{message}")
+    for i, choice in enumerate(choices, 1):
+        title = choice.title if hasattr(choice, "title") else str(choice)
+        print(f"  {i}) {title}")
+    while True:
+        raw = input("Enter number: ").strip()
+        if raw.isdigit() and 1 <= int(raw) <= len(choices):
+            c = choices[int(raw) - 1]
+            return c.value if hasattr(c, "value") else c
+        print(f"  Please enter a number between 1 and {len(choices)}.")
+
+
+def _nb_text(message: str, default: str = "", validate=None) -> str:
+    """Plain input() fallback for questionary.text()."""
+    while True:
+        raw = input(f"{message} ").strip()
+        if not raw and default:
+            raw = default
+        if validate is None:
+            return raw
+        result = validate(raw)
+        if result is True:
+            return raw
+        print(f"  {result}")
+
+
+def _nb_path(message: str, validate=None) -> str:
+    """Plain input() fallback for questionary.path()."""
+    return _nb_text(message, validate=validate)
+
+
+def _nb_confirm(message: str, default: bool = True) -> bool:
+    """y/n fallback for questionary.confirm()."""
+    hint = "Y/n" if default else "y/N"
+    while True:
+        raw = input(f"{message} [{hint}]: ").strip().lower()
+        if not raw:
+            return default
+        if raw in ("y", "yes"):
+            return True
+        if raw in ("n", "no"):
+            return False
+        print("  Please enter y or n.")
+
 # ── Choices ────────────────────────────────────────────────────────────────
 
 _TASK_CHOICES = [
@@ -58,6 +120,8 @@ _STRATEGY_FORMAT_HELP = {
 
 def prompt_task() -> str:
     """Ask the user to select a fine-tuning task."""
+    if _IN_NOTEBOOK:
+        return _nb_select("Select fine-tuning task:", _TASK_CHOICES)
     return questionary.select(
         "Select fine-tuning task:",
         choices=_TASK_CHOICES,
@@ -81,6 +145,15 @@ def prompt_model(recommended: str, alternatives: list[str]) -> str:
         choices.append(questionary.Choice(alt, value=alt))
     choices.append(questionary.Choice("Enter a custom model ID…", value="__custom__"))
 
+    if _IN_NOTEBOOK:
+        selection = _nb_select("Select a base model:", choices)
+        if selection == "__custom__":
+            selection = _nb_text(
+                "Enter HuggingFace model ID (e.g. meta-llama/Llama-3.2-1B):",
+                validate=lambda v: bool(v.strip()) or "Model ID cannot be empty",
+            )
+        return selection
+
     selection = questionary.select(
         "Select a base model:",
         choices=choices,
@@ -111,11 +184,16 @@ def prompt_dataset(task: str, strategy: str, training_service: "TrainingService"
     fmt = _STRATEGY_FORMAT_HELP.get(strategy) or _TASK_FORMAT_HELP.get(task, "JSON Lines file.")
     console.print(f"\n[dim]Expected format:[/dim] {fmt}")
 
+    _path_validate = lambda v: os.path.isfile(v) or "File not found — please enter a valid path"
+
     while True:
-        path = questionary.path(
-            "Path to dataset file (.jsonl / .json):",
-            validate=lambda v: os.path.isfile(v.strip()) or "File not found — please enter a valid path",
-        ).ask()
+        if _IN_NOTEBOOK:
+            path = _nb_path("Path to dataset file (.jsonl / .json):", validate=_path_validate)
+        else:
+            path = questionary.path(
+                "Path to dataset file (.jsonl / .json):",
+                validate=lambda v: os.path.isfile(v.strip()) or "File not found — please enter a valid path",,
+            ).ask()
 
         if path is not None:
             path = path.strip()
@@ -134,13 +212,18 @@ def prompt_dataset(task: str, strategy: str, training_service: "TrainingService"
             return path
         except Exception as exc:
             console.print(f"  [red]✗[/red] Validation failed: {exc}")
-            retry = questionary.confirm("Try a different file?", default=True).ask()
+            if _IN_NOTEBOOK:
+                retry = _nb_confirm("Try a different file?", default=True)
+            else:
+                retry = questionary.confirm("Try a different file?", default=True).ask()
             if not retry:
                 raise
 
 
 def prompt_provider() -> str:
     """Ask the user to choose a training provider."""
+    if _IN_NOTEBOOK:
+        return _nb_select("Select training provider:", _PROVIDER_CHOICES)
     return questionary.select(
         "Select training provider:",
         choices=_PROVIDER_CHOICES,
@@ -150,6 +233,8 @@ def prompt_provider() -> str:
 
 def prompt_strategy() -> str:
     """Ask the user to choose a training strategy."""
+    if _IN_NOTEBOOK:
+        return _nb_select("Select training strategy:", _STRATEGY_CHOICES)
     return questionary.select(
         "Select training strategy:",
         choices=_STRATEGY_CHOICES,
@@ -181,20 +266,28 @@ def prompt_hyperparams(defaults: dict) -> dict:
 
     def _ask_int(key: str, question: str) -> int:
         default = defaults.get(key)
-        raw = questionary.text(
-            f"{question} [default: {default}]:",
-            default=str(default),
-            validate=lambda v: v.isdigit() and int(v) >= 1 or f"Must be a positive integer",
-        ).ask()
+        validate = lambda v: v.isdigit() and int(v) >= 1 or "Must be a positive integer"
+        if _IN_NOTEBOOK:
+            raw = _nb_text(f"{question} [default: {default}]:", default=str(default), validate=validate)
+        else:
+            raw = questionary.text(
+                f"{question} [default: {default}]:",
+                default=str(default),
+                validate=validate,
+            ).ask()
         return int(raw)
 
     def _ask_float(key: str, question: str, min_val: float = 0.0) -> float:
         default = defaults.get(key)
-        raw = questionary.text(
-            f"{question} [default: {default}]:",
-            default=str(default),
-            validate=lambda v: _valid_float(v, min_val),
-        ).ask()
+        validate = lambda v: _valid_float(v, min_val)
+        if _IN_NOTEBOOK:
+            raw = _nb_text(f"{question} [default: {default}]:", default=str(default), validate=validate)
+        else:
+            raw = questionary.text(
+                f"{question} [default: {default}]:",
+                default=str(default),
+                validate=validate,
+            ).ask()
         return float(raw)
 
     def _valid_float(v: str, min_val: float) -> bool | str:
@@ -222,14 +315,30 @@ def prompt_hyperparams(defaults: dict) -> dict:
         questionary.Choice("None (full precision / no bitsandbytes required)", value="none"),
     ]
     default_quant = "4bit" if defaults.get("use_4bit") else ("8bit" if defaults.get("use_8bit") else "none")
-    quant = questionary.select(
-        f"Quantization [default: {default_quant}]:",
-        choices=quant_choices,
-        default=quant_choices[["4bit", "8bit", "none"].index(default_quant)],
-    ).ask()
+    if _IN_NOTEBOOK:
+        quant = _nb_select(f"Quantization [default: {default_quant}]:", quant_choices)
+    else:
+        quant = questionary.select(
+            f"Quantization [default: {default_quant}]:",
+            choices=quant_choices,
+            default=quant_choices[["4bit", "8bit", "none"].index(default_quant)],
+        ).ask()
     params["use_4bit"] = quant == "4bit"
     params["use_8bit"] = quant == "8bit"
 
+    if _IN_NOTEBOOK:
+        params["use_chat_template"] = _nb_confirm(
+            "Use model's native chat template for formatting? "
+            "(recommended for instruct models)",
+            default=False,
+        )
+    else:
+        params["use_chat_template"] = questionary.confirm(
+            "Use model's native chat template for formatting? "
+            "(recommended for instruct models)",
+            default=False,
+        ).ask()
+
     return params
 
 
@@ -263,6 +372,7 @@ def prompt_confirm_config(config: dict) -> bool:
         ("max_seq_length", "Max seq length"),
         ("use_4bit", "4-bit quantization"),
         ("use_8bit", "8-bit quantization"),
+        ("use_chat_template", "Use chat template"),
     ]
 
     for key, label in display_keys:
@@ -271,6 +381,8 @@ def prompt_confirm_config(config: dict) -> bool:
 
     console.print(table)
 
+    if _IN_NOTEBOOK:
+        return _nb_confirm("Start training with this configuration?", default=True)
     return questionary.confirm(
         "Start training with this configuration?", default=True
     ).ask()

{modelforge_finetuning-3.0.1 → modelforge_finetuning-3.0.2}/ModelForge/notebook_cli/wizard.py

@@ -225,6 +225,7 @@ class ModelForgeWizard:
             "max_seq_length": hyperparams.get("max_seq_length", 2048),
             "use_4bit": hyperparams.get("use_4bit", True),
             "use_8bit": hyperparams.get("use_8bit", False),
+            "use_chat_template": hyperparams.get("use_chat_template", False),
             # TrainingConfig defaults for the rest
             "lora_dropout": TrainingConfig.model_fields["lora_dropout"].default,
             "bnb_4bit_compute_dtype": TrainingConfig.model_fields["bnb_4bit_compute_dtype"].default,

{modelforge_finetuning-3.0.1 → modelforge_finetuning-3.0.2}/ModelForge/schemas/training_schemas.py

@@ -59,6 +59,9 @@ class TrainingConfig(BaseModel):
     # Sequence settings
     max_seq_length: Optional[int] = None
 
+    # Chat template settings
+    use_chat_template: bool = False
+
     # Evaluation settings
     eval_split: float = 0.2
     eval_steps: int = 100

{modelforge_finetuning-3.0.1 → modelforge_finetuning-3.0.2}/ModelForge/strategies/qlora_strategy.py

@@ -4,6 +4,12 @@ QLoRA combines 4-bit quantization with LoRA for memory-efficient fine-tuning.
 Uses TRL's SFTTrainer with QLoRA-optimized defaults.
 """
 from typing import Any, Dict
+
+try:
+    from jinja2.exceptions import TemplateError
+except ImportError:
+    TemplateError = Exception
+
 from peft import LoraConfig, TaskType, prepare_model_for_kbit_training
 
 # Import unsloth first to prevent EOS token corruption
@@ -114,12 +120,31 @@ class QLoRAStrategy:
         task = config.get("task", "text-generation")
         eos_token = tokenizer.eos_token or tokenizer.sep_token or ""
 
+        use_chat_template = config.get("use_chat_template", False)
+
         def format_to_text(example):
             """Format each example into a single text field for SFTTrainer."""
             if task == "text-generation":
                 prompt = example.get('prompt', '')
                 completion = example.get('completion', '')
-                text = f"USER: {prompt}\nASSISTANT: {completion}{eos_token}"
+
+                if use_chat_template:
+                    try:
+                        messages = [
+                            {"role": "user", "content": prompt},
+                            {"role": "assistant", "content": completion},
+                        ]
+                        text = tokenizer.apply_chat_template(
+                            messages, tokenize=False, add_generation_prompt=False
+                        )
+                    except (AttributeError, TemplateError, Exception) as e:
+                        logger.warning(
+                            f"Chat template unavailable ({e}), "
+                            f"falling back to USER/ASSISTANT format"
+                        )
+                        text = f"USER: {prompt}\nASSISTANT: {completion}{eos_token}"
+                else:
+                    text = f"USER: {prompt}\nASSISTANT: {completion}{eos_token}"
 
             elif task == "summarization":
                 input_text = example.get('input', '')

{modelforge_finetuning-3.0.1 → modelforge_finetuning-3.0.2}/ModelForge/strategies/sft_strategy.py

@@ -3,6 +3,12 @@ Supervised Fine-Tuning (SFT) strategy implementation.
 Uses TRL's SFTTrainer for standard supervised fine-tuning with LoRA.
 """
 from typing import Any, Dict
+
+try:
+    from jinja2.exceptions import TemplateError
+except ImportError:
+    TemplateError = Exception
+
 from peft import LoraConfig, TaskType, prepare_model_for_kbit_training
 
 # Import unsloth first to prevent EOS token corruption
@@ -93,12 +99,31 @@ class SFTStrategy:
         task = config.get("task", "text-generation")
         eos_token = tokenizer.eos_token or tokenizer.sep_token or ""
 
+        use_chat_template = config.get("use_chat_template", False)
+
         def format_to_text(example):
             """Format each example into a single text field for SFTTrainer."""
             if task == "text-generation":
                 prompt = example.get('prompt', '')
                 completion = example.get('completion', '')
-                text = f"USER: {prompt}\nASSISTANT: {completion}{eos_token}"
+
+                if use_chat_template:
+                    try:
+                        messages = [
+                            {"role": "user", "content": prompt},
+                            {"role": "assistant", "content": completion},
+                        ]
+                        text = tokenizer.apply_chat_template(
+                            messages, tokenize=False, add_generation_prompt=False
+                        )
+                    except (AttributeError, TemplateError, Exception) as e:
+                        logger.warning(
+                            f"Chat template unavailable ({e}), "
+                            f"falling back to USER/ASSISTANT format"
+                        )
+                        text = f"USER: {prompt}\nASSISTANT: {completion}{eos_token}"
+                else:
+                    text = f"USER: {prompt}\nASSISTANT: {completion}{eos_token}"
 
             elif task == "summarization":
                 input_text = example.get('input', '')

{modelforge_finetuning-3.0.1 → modelforge_finetuning-3.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelforge-finetuning
-Version: 3.0.1
+Version: 3.0.2
 Summary: ModelForge: A no-code toolkit for fine-tuning HuggingFace models
 Author-email: R3tr0 M1ll3r <r3tr0.m1ll3r@gmail.com>
 Project-URL: Documentation, https://modelforge-finetuning.readthedocs.io

{modelforge_finetuning-3.0.1 → modelforge_finetuning-3.0.2}/modelforge_finetuning.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelforge-finetuning
-Version: 3.0.1
+Version: 3.0.2
 Summary: ModelForge: A no-code toolkit for fine-tuning HuggingFace models
 Author-email: R3tr0 M1ll3r <r3tr0.m1ll3r@gmail.com>
 Project-URL: Documentation, https://modelforge-finetuning.readthedocs.io

{modelforge_finetuning-3.0.1 → modelforge_finetuning-3.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "modelforge-finetuning"
-version = "3.0.1"
+version = "3.0.2"
 description = "ModelForge: A no-code toolkit for fine-tuning HuggingFace models"
 authors = [
     {name = "R3tr0 M1ll3r", email = "r3tr0.m1ll3r@gmail.com"},