modelforge-finetuning 3.0.3__tar.gz → 3.0.5__tar.gz

{modelforge_finetuning-3.0.3 → modelforge_finetuning-3.0.5}/ModelForge/cli.py

@@ -65,14 +65,14 @@ def main():
         subcommand = sys.argv[1]
         if subcommand == "cli":
             try:
-                from .notebook_cli.wizard import main as cli_main
+                from .notebook_cli.wizard import ModelForgeWizard
             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()
+            ModelForgeWizard(notebook=False).run()
             return
         else:
             print(f"Unknown subcommand: '{subcommand}'")

{modelforge_finetuning-3.0.3 → modelforge_finetuning-3.0.5}/ModelForge/evaluation/metrics.py

@@ -21,6 +21,10 @@ class MetricsCalculator:
         - Perplexity: exp(loss)
         - Loss: Cross-entropy loss
 
+        Note: When preprocess_logits_for_metrics is used, predictions contain
+        pre-computed scalar losses (one per eval batch) instead of full logit tensors.
+        This prevents RAM exhaustion during evaluation.
+
         Args:
             eval_pred: Evaluation prediction with predictions and labels
 
@@ -29,28 +33,16 @@ class MetricsCalculator:
         """
         logger.info("Computing causal LM metrics")
 
-        import torch
-        import torch.nn.functional as F
-
-        predictions, labels = eval_pred.predictions, eval_pred.label_ids
-
-        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()
+        predictions = eval_pred.predictions
 
-        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))
+        # predictions is shape (num_eval_batches, 1) of pre-computed scalar losses
+        # (from _preprocess_logits_for_metrics in sft_strategy.py)
+        mean_loss = float(np.mean(predictions))
+        perplexity = float(np.exp(mean_loss))
 
         metrics = {
             "perplexity": perplexity,
-            "eval_loss": float(loss),
+            "eval_loss": mean_loss,
         }
 
         logger.info(f"Causal LM metrics: {metrics}")

{modelforge_finetuning-3.0.3 → modelforge_finetuning-3.0.5}/ModelForge/notebook_cli/__init__.py

@@ -12,7 +12,8 @@ Usage from a notebook cell:
     run_cli()
 
 Usage from a terminal:
-    modelforge-nb
+    modelforge-nb          (notebook-safe input() prompts)
+    modelforge cli         (interactive terminal with questionary)
 """
 from .wizard import ModelForgeWizard, main as run_cli
 

{modelforge_finetuning-3.0.3 → modelforge_finetuning-3.0.5}/ModelForge/notebook_cli/progress.py

@@ -7,8 +7,13 @@ notebook environment, and falls back to tqdm for plain terminal use.
 from __future__ import annotations
 
 
+_NOTEBOOK_OVERRIDE: bool | None = None
+
+
 def _is_notebook() -> bool:
     """Return True if running inside a Jupyter-compatible notebook kernel."""
+    if _NOTEBOOK_OVERRIDE is not None:
+        return _NOTEBOOK_OVERRIDE
     try:
         from IPython import get_ipython
         shell = get_ipython()
@@ -19,6 +24,12 @@ def _is_notebook() -> bool:
         return False
 
 
+def set_notebook_mode(mode: bool) -> None:
+    """Override the auto-detected notebook mode."""
+    global _NOTEBOOK_OVERRIDE
+    _NOTEBOOK_OVERRIDE = mode
+
+
 class ProgressDisplay:
     """
     Unified progress display that works in notebooks and terminals.

{modelforge_finetuning-3.0.3 → modelforge_finetuning-3.0.5}/ModelForge/notebook_cli/prompts.py

@@ -33,6 +33,12 @@ def _is_notebook() -> bool:
 _IN_NOTEBOOK = _is_notebook()
 
 
+def set_notebook_mode(mode: bool) -> None:
+    """Override the auto-detected notebook mode."""
+    global _IN_NOTEBOOK
+    _IN_NOTEBOOK = mode
+
+
 # ── Notebook-safe input() fallbacks ──────────────────────────────────────────
 
 def _nb_select(message: str, choices: list) -> str:
@@ -83,6 +89,14 @@ def _nb_confirm(message: str, default: bool = True) -> bool:
 
 # ── Choices ────────────────────────────────────────────────────────────────
 
+_MAIN_MENU_CHOICES = [
+    questionary.Choice("Fine-tune a model", value="train"),
+    questionary.Choice("List past models", value="list"),
+    questionary.Choice("Test a fine-tuned model", value="test"),
+    questionary.Choice("Exit", value="exit"),
+]
+
+
 _TASK_CHOICES = [
     questionary.Choice("Text Generation  (causal LM fine-tuning)", value="text-generation"),
     questionary.Choice("Summarization    (seq-to-seq fine-tuning)", value="summarization"),
@@ -342,6 +356,49 @@ def prompt_hyperparams(defaults: dict) -> dict:
     return params
 
 
+def prompt_main_menu() -> str:
+    """Ask the user what they want to do."""
+    if _IN_NOTEBOOK:
+        return _nb_select("What would you like to do?", _MAIN_MENU_CHOICES)
+    return questionary.select(
+        "What would you like to do?",
+        choices=_MAIN_MENU_CHOICES,
+        style=questionary.Style([("selected", "fg:cyan bold")]),
+    ).ask()
+
+
+def prompt_select_model(models: list[dict]) -> dict | None:
+    """
+    Ask the user to select a model from a list.
+
+    Args:
+        models: List of model dictionaries from the database.
+
+    Returns:
+        Selected model dict, or None if cancelled.
+    """
+    choices = []
+    for m in models:
+        label = (
+            f"{m.get('name', 'unknown')}  "
+            f"[{m.get('task', '?')} / {m.get('strategy', '?')}]"
+        )
+        choices.append(questionary.Choice(label, value=m["id"]))
+
+    if _IN_NOTEBOOK:
+        model_id = _nb_select("Select a model:", choices)
+    else:
+        model_id = questionary.select(
+            "Select a model:",
+            choices=choices,
+            style=questionary.Style([("selected", "fg:cyan bold")]),
+        ).ask()
+
+    if model_id is None:
+        return None
+    return next((m for m in models if m["id"] == model_id), None)
+
+
 def prompt_confirm_config(config: dict) -> bool:
     """
     Show a summary table of the final config and ask for confirmation.

{modelforge_finetuning-3.0.3 → modelforge_finetuning-3.0.5}/ModelForge/notebook_cli/wizard.py

@@ -30,57 +30,165 @@ class ModelForgeWizard:
     Uses existing Python service classes directly — no REST API calls.
     """
 
-    def __init__(self):
+    def __init__(self, notebook: bool | None = None):
         from rich.console import Console
 
         self.console = Console()
 
+        if notebook is not None:
+            from . import prompts, progress
+            prompts.set_notebook_mode(notebook)
+            progress.set_notebook_mode(notebook)
+
     # ── Public ─────────────────────────────────────────────────────────────
 
     def run(self) -> None:
-        """Execute the full wizard flow."""
-        from pydantic import ValidationError
-
-        from ..schemas.training_schemas import TrainingConfig
-        from .prompts import prompt_confirm_config
+        """Show main menu in a loop, dispatching until the user exits."""
+        from .prompts import prompt_main_menu
 
         try:
             self._print_banner()
-            hardware_info = self._detect_hardware()
-            task = self._select_task()
-            model_name = self._select_model(task, hardware_info)
-            provider = self._select_provider()
-            strategy = self._select_strategy()
-            dataset_path = self._select_dataset(task, strategy)
-            hyperparams = self._configure_hyperparams(hardware_info, strategy)
-            config = self._build_config(
-                task=task,
-                model_name=model_name,
-                provider=provider,
-                strategy=strategy,
-                dataset=dataset_path,
-                compute_specs=hardware_info.get("compute_profile", "low_end"),
-                hyperparams=hyperparams,
-            )
-            try:
-                TrainingConfig(**config)
-            except ValidationError as exc:
-                errors = "; ".join(e["msg"] for e in exc.errors())
-                self.console.print(
-                    f"\n[red bold]Invalid configuration:[/red bold] {errors}"
-                )
-                return
-            confirmed = prompt_confirm_config(config)
-            if not confirmed:
-                self.console.print("\n[yellow]Training cancelled.[/yellow]")
-                return
-            self._run_training(config)
+            while True:
+                action = prompt_main_menu()
+                if action is None or action == "exit":
+                    self.console.print("\n[dim]Goodbye![/dim]")
+                    return
+                if action == "train":
+                    self._run_train_wizard()
+                elif action == "list":
+                    self._list_models()
+                elif action == "test":
+                    self._test_model()
         except KeyboardInterrupt:
             self.console.print("\n\n[yellow]Interrupted — goodbye.[/yellow]")
         except Exception as exc:
             self.console.print(f"\n[red bold]Error:[/red bold] {exc}")
             raise
 
+    def _run_train_wizard(self) -> None:
+        """Execute the full training wizard flow."""
+        from pydantic import ValidationError
+
+        from ..schemas.training_schemas import TrainingConfig
+        from .prompts import prompt_confirm_config
+
+        hardware_info = self._detect_hardware()
+        task = self._select_task()
+        model_name = self._select_model(task, hardware_info)
+        provider = self._select_provider()
+        strategy = self._select_strategy()
+        dataset_path = self._select_dataset(task, strategy)
+        hyperparams = self._configure_hyperparams(hardware_info, strategy)
+        config = self._build_config(
+            task=task,
+            model_name=model_name,
+            provider=provider,
+            strategy=strategy,
+            dataset=dataset_path,
+            compute_specs=hardware_info.get("compute_profile", "low_end"),
+            hyperparams=hyperparams,
+        )
+        try:
+            TrainingConfig(**config)
+        except ValidationError as exc:
+            errors = "; ".join(e["msg"] for e in exc.errors())
+            self.console.print(
+                f"\n[red bold]Invalid configuration:[/red bold] {errors}"
+            )
+            return
+        confirmed = prompt_confirm_config(config)
+        if not confirmed:
+            self.console.print("\n[yellow]Training cancelled.[/yellow]")
+            return
+        self._run_training(config)
+
+    # ── List & Test ────────────────────────────────────────────────────────
+
+    def _list_models(self) -> None:
+        """Display a table of all fine-tuned models."""
+        from rich.table import Table
+
+        from ..dependencies import get_model_service
+
+        self.console.print("\n[bold]Past Fine-Tuned Models[/bold]\n")
+        model_service = get_model_service()
+        models = model_service.get_all_models()
+
+        if not models:
+            self.console.print("  [dim]No models found.[/dim]")
+            return
+
+        table = Table(show_header=True, header_style="bold cyan")
+        table.add_column("#", style="dim", width=3)
+        table.add_column("Name")
+        table.add_column("Base Model")
+        table.add_column("Task")
+        table.add_column("Strategy")
+        table.add_column("Provider")
+        table.add_column("Created")
+        table.add_column("Path", style="dim")
+
+        for i, m in enumerate(models, 1):
+            created = m.get("created_at", "")
+            if created:
+                created = created[:16].replace("T", " ")
+            table.add_row(
+                str(i),
+                m.get("name", "—"),
+                m.get("base_model", "—"),
+                m.get("task", "—"),
+                m.get("strategy", "—"),
+                m.get("provider", "—"),
+                created,
+                m.get("path", "—"),
+            )
+
+        self.console.print(table)
+
+    def _test_model(self) -> None:
+        """Let the user pick a fine-tuned model and launch the playground."""
+        import os
+
+        from rich.panel import Panel
+
+        from ..dependencies import get_model_service
+        from .prompts import prompt_select_model
+
+        self.console.print("\n[bold]Test a Fine-Tuned Model[/bold]\n")
+        model_service = get_model_service()
+        models = model_service.get_all_models()
+
+        if not models:
+            self.console.print("  [dim]No models found. Fine-tune a model first.[/dim]")
+            return
+
+        selected = prompt_select_model(models)
+        if selected is None:
+            return
+
+        model_path = selected.get("path", "")
+        if not model_path or not os.path.isdir(model_path):
+            self.console.print(
+                f"\n[red]Model path not found:[/red] {model_path}"
+            )
+            return
+
+        self.console.print(
+            Panel(
+                f"[bold]Model:[/bold]  {selected.get('name', '—')}\n"
+                f"[bold]Path:[/bold]   {model_path}\n\n"
+                "[dim]Type /bye to exit, /view_settings to inspect the model.[/dim]",
+                title="Playground",
+                border_style="cyan",
+                expand=False,
+            )
+        )
+
+        from ..utilities.chat_playground import PlaygroundModel
+
+        bot = PlaygroundModel(model_path=model_path)
+        bot.chat()
+
     # ── Steps ───────────────────────────────────────────────────────────────
 
     def _print_banner(self) -> None:
@@ -317,7 +425,7 @@ class ModelForgeWizard:
 # ── Entry point ──────────────────────────────────────────────────────────────
 
 def main() -> None:
-    """Entry point for the ``modelforge-nb`` console script."""
+    """Entry point for the ``modelforge-nb`` console script (notebook mode)."""
     try:
         import questionary  # noqa: F401
         import rich  # noqa: F401
@@ -330,7 +438,7 @@ def main() -> None:
             '    pip install "modelforge-finetuning[cli]"\n'
         )
         sys.exit(1)
-    ModelForgeWizard().run()
+    ModelForgeWizard(notebook=True).run()
 
 
 if __name__ == "__main__":

{modelforge_finetuning-3.0.3 → modelforge_finetuning-3.0.5}/ModelForge/services/training_service.py

@@ -432,7 +432,16 @@ class TrainingService:
 
             # Train
             self.training_status["message"] = "Training in progress..."
-            trainer.train()
+            provider_name = config.get("provider", "")
+            if provider_name == "unsloth":
+                try:
+                    from unsloth import unsloth_train
+                    unsloth_train(trainer)
+                except ImportError:
+                    logger.warning("unsloth_train not available, falling back to trainer.train()")
+                    trainer.train()
+            else:
+                trainer.train()
 
             # Save model
             self.training_status["message"] = "Saving model..."

{modelforge_finetuning-3.0.3 → modelforge_finetuning-3.0.5}/ModelForge/strategies/qlora_strategy.py

@@ -22,6 +22,7 @@ except ImportError:
 from trl import SFTTrainer, SFTConfig
 
 from ..logging_config import logger
+from .sft_strategy import _preprocess_logits_for_metrics
 
 
 class QLoRAStrategy:
@@ -211,7 +212,7 @@ class QLoRAStrategy:
             max_seq_length = 2048
 
         # QLoRA-optimized training arguments
-        training_args = SFTConfig(
+        sft_kwargs = dict(
             output_dir=config.get("output_dir", "./checkpoints"),
             num_train_epochs=config.get("num_train_epochs", 1),
             per_device_train_batch_size=config.get("per_device_train_batch_size", 4),
@@ -227,7 +228,6 @@ class QLoRAStrategy:
             bf16=config.get("bf16", True),  # Default True for CUDA; MPS overrides to False in training_service
             max_grad_norm=config.get("max_grad_norm", 0.3),
             max_steps=config.get("max_steps", -1),
-            group_by_length=config.get("group_by_length", True),
             lr_scheduler_type=config.get("lr_scheduler_type", "cosine"),
             report_to="tensorboard",
             logging_dir=config.get("logging_dir", "./training_logs"),
@@ -245,12 +245,17 @@ class QLoRAStrategy:
             load_best_model_at_end=True if eval_dataset else False,
             metric_for_best_model="eval_loss" if eval_dataset else None,
             ddp_find_unused_parameters=False,
-            use_cache=False,
             # Dataloader settings (MPS sets these to avoid multiprocessing issues)
             dataloader_num_workers=config.get("dataloader_num_workers", 0),
             dataloader_pin_memory=config.get("dataloader_pin_memory", True),
         )
 
+        # Unsloth's patched SFTConfig doesn't support group_by_length
+        if not config.get("_peft_already_applied"):
+            sft_kwargs["group_by_length"] = config.get("group_by_length", True)
+
+        training_args = SFTConfig(**sft_kwargs)
+
         # Build the PEFT config for SFTTrainer to apply LoRA
         # Skip if PEFT was already applied (e.g. by Unsloth provider)
         peft_config = None if config.get("_peft_already_applied") else self.get_peft_config(config)
@@ -265,6 +270,7 @@ class QLoRAStrategy:
             peft_config=peft_config,
             callbacks=callbacks or [],
             compute_metrics=compute_metrics,
+            preprocess_logits_for_metrics=_preprocess_logits_for_metrics,
         )
 
         logger.info("QLoRA SFTTrainer created successfully")

{modelforge_finetuning-3.0.3 → modelforge_finetuning-3.0.5}/ModelForge/strategies/sft_strategy.py

@@ -23,6 +23,37 @@ from trl import SFTTrainer, SFTConfig
 from ..logging_config import logger
 
 
+def _preprocess_logits_for_metrics(logits, labels):
+    """
+    Reduce logit tensors to scalar loss per batch before CPU accumulation.
+
+    This prevents RAM exhaustion when the Trainer accumulates eval predictions.
+    Instead of storing full logit tensors (batch × seq_len × vocab_size),
+    we compute the loss on GPU and return only a scalar, reducing memory by
+    orders of magnitude (e.g., 19.7 GB/batch → bytes/batch).
+
+    Args:
+        logits: Model logits (batch, seq_len, vocab_size)
+        labels: Token labels (batch, seq_len)
+
+    Returns:
+        Scalar loss tensor for this batch, shape (1,)
+    """
+    import torch.nn.functional as F
+
+    shift_logits = logits[..., :-1, :].contiguous()
+    shift_labels = labels[..., 1:].contiguous()
+
+    loss = F.cross_entropy(
+        shift_logits.view(-1, shift_logits.size(-1)),
+        shift_labels.view(-1).long(),
+        ignore_index=-100,
+        reduction="mean",
+    )
+
+    return loss.unsqueeze(0)
+
+
 class SFTStrategy:
     """Supervised Fine-Tuning strategy using TRL's SFTTrainer."""
 
@@ -193,7 +224,7 @@ class SFTStrategy:
             max_seq_length = 2048
 
         # Create SFTConfig with training arguments
-        training_args = SFTConfig(
+        sft_kwargs = dict(
             output_dir=config.get("output_dir", "./checkpoints"),
             num_train_epochs=config.get("num_train_epochs", 1),
             per_device_train_batch_size=config.get("per_device_train_batch_size", 1),
@@ -209,7 +240,6 @@ class SFTStrategy:
             bf16=config.get("bf16", False),
             max_grad_norm=config.get("max_grad_norm", 0.3),
             max_steps=config.get("max_steps", -1),
-            group_by_length=config.get("group_by_length", True),
             lr_scheduler_type=config.get("lr_scheduler_type", "cosine"),
             report_to="tensorboard",
             logging_dir=config.get("logging_dir", "./training_logs"),
@@ -229,6 +259,12 @@ class SFTStrategy:
             dataloader_pin_memory=config.get("dataloader_pin_memory", True),
         )
 
+        # Unsloth's patched SFTConfig doesn't support group_by_length
+        if not config.get("_peft_already_applied"):
+            sft_kwargs["group_by_length"] = config.get("group_by_length", True)
+
+        training_args = SFTConfig(**sft_kwargs)
+
         # Build the PEFT config for SFTTrainer to apply LoRA
         # Skip if PEFT was already applied (e.g. by Unsloth provider)
         peft_config = None if config.get("_peft_already_applied") else self.get_peft_config(config)
@@ -243,6 +279,7 @@ class SFTStrategy:
             peft_config=peft_config,
             callbacks=callbacks or [],
             compute_metrics=compute_metrics,
+            preprocess_logits_for_metrics=_preprocess_logits_for_metrics,
         )
 
         logger.info("SFTTrainer created successfully")

{modelforge_finetuning-3.0.3 → modelforge_finetuning-3.0.5}/ModelForge/strategies/strategy_factory.py

@@ -1,22 +1,42 @@
 """
 Strategy factory for creating training strategy instances.
+
+Strategy imports are deferred to avoid pulling in heavy dependencies (trl, wandb)
+at module load time — which would break lightweight entry points like the notebook
+CLI wizard that only need HardwareService.
 """
-from .sft_strategy import SFTStrategy
-from .rlhf_strategy import RLHFStrategy
-from .dpo_strategy import DPOStrategy
-from .qlora_strategy import QLoRAStrategy
 from ..exceptions import ConfigurationError
 from ..logging_config import logger
 
 
+def _import_sft():
+    from .sft_strategy import SFTStrategy
+    return SFTStrategy
+
+
+def _import_rlhf():
+    from .rlhf_strategy import RLHFStrategy
+    return RLHFStrategy
+
+
+def _import_dpo():
+    from .dpo_strategy import DPOStrategy
+    return DPOStrategy
+
+
+def _import_qlora():
+    from .qlora_strategy import QLoRAStrategy
+    return QLoRAStrategy
+
+
 class StrategyFactory:
     """Factory for creating training strategy instances."""
 
-    _strategies = {
-        "sft": SFTStrategy,
-        "rlhf": RLHFStrategy,
-        "dpo": DPOStrategy,
-        "qlora": QLoRAStrategy,
+    _strategy_loaders = {
+        "sft": _import_sft,
+        "rlhf": _import_rlhf,
+        "dpo": _import_dpo,
+        "qlora": _import_qlora,
     }
 
     @classmethod
@@ -37,13 +57,13 @@ class StrategyFactory:
 
         strategy_name = strategy_name.lower()
 
-        if strategy_name not in cls._strategies:
+        if strategy_name not in cls._strategy_loaders:
             raise ConfigurationError(
                 f"Unknown training strategy: {strategy_name}. "
-                f"Available strategies: {list(cls._strategies.keys())}"
+                f"Available strategies: {list(cls._strategy_loaders.keys())}"
             )
 
-        strategy_class = cls._strategies[strategy_name]
+        strategy_class = cls._strategy_loaders[strategy_name]()
         return strategy_class()
 
     @classmethod
@@ -54,7 +74,7 @@ class StrategyFactory:
         Returns:
             List of strategy names
         """
-        return list(cls._strategies.keys())
+        return list(cls._strategy_loaders.keys())
 
     @classmethod
     def register_strategy(cls, name: str, strategy_class):
@@ -66,4 +86,4 @@ class StrategyFactory:
             strategy_class: Strategy class
         """
         logger.info(f"Registering strategy: {name}")
-        cls._strategies[name.lower()] = strategy_class
+        cls._strategy_loaders[name.lower()] = lambda _cls=strategy_class: _cls

{modelforge_finetuning-3.0.3 → modelforge_finetuning-3.0.5}/ModelForge/utilities/chat_playground.py

@@ -78,7 +78,7 @@ class PlaygroundModel:
             input("\nPress Enter to exit...")
             exit(1)
         except KeyError:
-            print(f"Pipeline task {self.modelforge_config['pipeline_task']} not found in definitions for the pipeline object of transformers.")
+            print(traceback.format_exc())
             input("\nPress Enter to exit...")
             exit(1)
         except Exception as e:

{modelforge_finetuning-3.0.3/modelforge_finetuning.egg-info → modelforge_finetuning-3.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelforge-finetuning
-Version: 3.0.3
+Version: 3.0.5
 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
@@ -36,6 +36,9 @@ Requires-Dist: questionary>=2.0.1; extra == "cli"
 Requires-Dist: rich>=13.0.0; extra == "cli"
 Requires-Dist: ipywidgets>=8.0.0; extra == "cli"
 Requires-Dist: ipython>=8.0.0; extra == "cli"
+Provides-Extra: unsloth
+Requires-Dist: unsloth; extra == "unsloth"
+Requires-Dist: bitsandbytes==0.45.3; extra == "unsloth"
 Dynamic: license-file
 
 # ModelForge 🔧⚡

{modelforge_finetuning-3.0.3 → modelforge_finetuning-3.0.5/modelforge_finetuning.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelforge-finetuning
-Version: 3.0.3
+Version: 3.0.5
 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
@@ -36,6 +36,9 @@ Requires-Dist: questionary>=2.0.1; extra == "cli"
 Requires-Dist: rich>=13.0.0; extra == "cli"
 Requires-Dist: ipywidgets>=8.0.0; extra == "cli"
 Requires-Dist: ipython>=8.0.0; extra == "cli"
+Provides-Extra: unsloth
+Requires-Dist: unsloth; extra == "unsloth"
+Requires-Dist: bitsandbytes==0.45.3; extra == "unsloth"
 Dynamic: license-file
 
 # ModelForge 🔧⚡

{modelforge_finetuning-3.0.3 → modelforge_finetuning-3.0.5}/modelforge_finetuning.egg-info/requires.txt

@@ -27,3 +27,7 @@ ipython>=8.0.0
 
 [quantization]
 bitsandbytes==0.45.3
+
+[unsloth]
+unsloth
+bitsandbytes==0.45.3

{modelforge_finetuning-3.0.3 → modelforge_finetuning-3.0.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "modelforge-finetuning"
-version = "3.0.3"
+version = "3.0.5"
 description = "ModelForge: A no-code toolkit for fine-tuning HuggingFace models"
 authors = [
     {name = "R3tr0 M1ll3r", email = "r3tr0.m1ll3r@gmail.com"},
@@ -40,6 +40,10 @@ cli = [
     "ipywidgets>=8.0.0",
     "ipython>=8.0.0",
 ]
+unsloth = [
+    "unsloth",
+    "bitsandbytes==0.45.3",
+]
 
 [tool.setuptools.packages.find]
 where = ["."]