rpeft 0.1.0

data/python/rpeft_backend/_training.py

@@ -0,0 +1,170 @@
+import gc
+import os
+import shutil
+
+from . import _data, _device, _models
+from ._errors import stage
+
+
+def train_lora(config):
+    lora = config.get("lora", {})
+    resolved = _device.resolve_device(config.get("device"))
+    device = resolved["device"]
+    dtype = resolved["dtype"]
+    output_dir = config["output_dir"]
+
+    model = None
+    try:
+        tokenizer, model = _models.load_tokenizer_and_model(
+            config["base_model"],
+            dtype=dtype,
+            device=device,
+            trust_remote_code=config.get("trust_remote_code", False),
+        )
+        dataset = _data.load_tokenized_dataset(
+            config["dataset_path"],
+            tokenizer,
+            text_field=config.get("text_field", "text"),
+            max_length=config.get("max_length", 512),
+            dataset_format=config.get("dataset_format", "text"),
+        )
+        eval_dataset = None
+        if config.get("eval_dataset_path"):
+            eval_dataset = _data.load_tokenized_dataset(
+                config["eval_dataset_path"],
+                tokenizer,
+                text_field=config.get("text_field", "text"),
+                max_length=config.get("max_length", 512),
+                dataset_format=config.get("dataset_format", "text"),
+            )
+
+        with stage("training"):
+            model, target_modules, param_counts = _apply_lora(model, lora)
+            trainer = _build_trainer(model, tokenizer, dataset, eval_dataset, config, device, dtype)
+            resume = _resume_point(config)
+            metrics = trainer.train(resume_from_checkpoint=resume).metrics
+            steps = trainer.state.global_step
+            if eval_dataset is not None:
+                metrics = dict(metrics, **trainer.evaluate())
+
+        with stage("adapter_save"):
+            model.save_pretrained(output_dir)
+            # Checkpoints only serve resuming an interrupted run. Once the adapter is saved they would
+            # just travel with it wherever the adapter directory is saved or shared.
+            shutil.rmtree(_trainer_dir(output_dir), ignore_errors=True)
+
+        return _result(
+            config, device, dtype, target_modules, param_counts, metrics, steps, len(dataset)
+        )
+    finally:
+        model = None
+        gc.collect()
+        _device.empty_cache(device)
+
+
+def _apply_lora(model, lora):
+    from peft import LoraConfig, TaskType, get_peft_model
+
+    lora_config = LoraConfig(
+        r=lora.get("r", 8),
+        lora_alpha=lora.get("alpha", 16),
+        lora_dropout=lora.get("dropout", 0.05),
+        # None lets PEFT pick per-architecture defaults (e.g. q_proj/v_proj).
+        target_modules=lora.get("target_modules"),
+        bias="none",
+        task_type=TaskType.CAUSAL_LM,
+    )
+    model = get_peft_model(model, lora_config)
+    model.print_trainable_parameters()
+
+    target_modules = model.peft_config["default"].target_modules
+    if isinstance(target_modules, (set, frozenset)):
+        target_modules = sorted(target_modules)
+    elif isinstance(target_modules, str):
+        target_modules = [target_modules]
+    else:
+        target_modules = list(target_modules)
+
+    return model, target_modules, model.get_nb_trainable_parameters()
+
+
+def _build_trainer(model, tokenizer, dataset, eval_dataset, config, device, dtype):
+    from transformers import Trainer, TrainingArguments
+
+    args = TrainingArguments(
+        output_dir=_trainer_dir(config["output_dir"]),
+        num_train_epochs=config.get("epochs", 3),
+        per_device_train_batch_size=config.get("batch_size", 4),
+        learning_rate=config.get("learning_rate", 2e-4),
+        logging_steps=config.get("logging_steps", 5),
+        logging_strategy="steps",
+        eval_strategy="epoch" if eval_dataset is not None else "no",
+        save_strategy=config.get("save_strategy", "no"),
+        report_to=[],
+        seed=config.get("seed", 42),
+        bf16=(dtype == "bfloat16"),
+        fp16=False,
+        dataloader_pin_memory=(device == "cuda"),
+        use_cpu=(device == "cpu"),
+        optim="adamw_torch",
+    )
+    return Trainer(
+        model=model,
+        args=args,
+        train_dataset=dataset,
+        eval_dataset=eval_dataset,
+        data_collator=_collator(tokenizer),
+    )
+
+
+def _result(config, device, dtype, target_modules, param_counts, metrics, steps, num_examples):
+    trainable_params, total_params = param_counts
+    effective = dict(config)
+    effective["device"] = device
+    effective["lora"] = dict(config.get("lora", {}))
+    effective["lora"]["target_modules"] = target_modules
+
+    return {
+        "adapter_path": config["output_dir"],
+        "base_model": config["base_model"],
+        "device": device,
+        "dtype": dtype,
+        "train_runtime_seconds": float(metrics.get("train_runtime", 0.0)),
+        "final_loss": float(metrics.get("train_loss", 0.0)),
+        "eval_loss": float(metrics["eval_loss"]) if "eval_loss" in metrics else None,
+        "num_examples": int(num_examples),
+        "steps": int(steps),
+        "trainable_params": int(trainable_params),
+        "total_params": int(total_params),
+        "effective_config": effective,
+    }
+
+
+def _trainer_dir(output_dir):
+    return os.path.join(output_dir, ".trainer")
+
+
+def _resume_point(config):
+    if not config.get("resume_from_checkpoint"):
+        return None
+
+    from transformers.trainer_utils import get_last_checkpoint
+
+    # A finished run removes its checkpoints, so there may be nothing to resume; train from the start then.
+    trainer_dir = _trainer_dir(config["output_dir"])
+    return get_last_checkpoint(trainer_dir) if os.path.isdir(trainer_dir) else None
+
+
+def _collator(tokenizer):
+    # DataCollatorForLanguageModeling ignores every position holding the pad token. Tokenizers without
+    # a pad token of their own pad with EOS (see _models.load_tokenizer), and many that have one reuse
+    # EOS too, so the EOS that ends each example would never be learned. Only the padding the batch
+    # added is ignored here, found through the attention mask instead of the token id.
+    def collate(features):
+        batch = tokenizer.pad(features, return_tensors="pt")
+        labels = batch["input_ids"].clone()
+        labels[batch["attention_mask"] == 0] = -100
+        batch["labels"] = labels
+        return batch
+
+    return collate

data/python/rpeft_backend/_versions.py

@@ -0,0 +1,39 @@
+import importlib.metadata
+import re
+
+from ._errors import BackendError
+
+# transformers 4.56 is the first release that accepts the dtype argument the backend passes, and it loads
+# checkpoints and .bin model files only with torch 2.6 or later.
+MINIMUMS = {"torch": "2.6", "transformers": "4.56"}
+
+
+def installed_version(name):
+    try:
+        return importlib.metadata.version(name)
+    except importlib.metadata.PackageNotFoundError:
+        return None
+
+
+def is_outdated(name, version):
+    minimum = MINIMUMS.get(name)
+    if minimum is None or version is None:
+        return False
+    return _parse(version) < _parse(minimum)
+
+
+def require_minimums():
+    outdated = [
+        "%s %s (needs %s or later)" % (name, version, MINIMUMS[name])
+        for name in MINIMUMS
+        for version in [installed_version(name)]
+        if is_outdated(name, version)
+    ]
+    if outdated:
+        raise BackendError("dependency", "outdated Python packages: %s" % ", ".join(outdated))
+
+
+def _parse(version):
+    # Local suffixes such as "2.6.0+cpu" and pre-release tags are ignored; only the release numbers count.
+    match = re.match(r"\d+(?:\.\d+)*", version)
+    return tuple(int(part) for part in match.group(0).split(".")) if match else ()

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: rpeft
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Koichi ITO
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fiddle
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pycall
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+description: A Ruby interface for LoRA fine-tuning of large language models. It drives
+  PyTorch, Hugging Face Transformers, and PEFT through PyCall, modeling the train,
+  adapter, and merge lifecycle with a Ruby API and CLI.
+email:
+- koic.ito@gmail.com
+executables:
+- rpeft
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- LICENSE.txt
+- README.md
+- exe/rpeft
+- lib/rpeft.rb
+- lib/rpeft/arguments.rb
+- lib/rpeft/backend.rb
+- lib/rpeft/backend/error_translation.rb
+- lib/rpeft/backend/python.rb
+- lib/rpeft/cli.rb
+- lib/rpeft/cli/command.rb
+- lib/rpeft/cli/doctor.rb
+- lib/rpeft/cli/generate.rb
+- lib/rpeft/cli/lora_merge.rb
+- lib/rpeft/cli/lora_train.rb
+- lib/rpeft/dataset.rb
+- lib/rpeft/device.rb
+- lib/rpeft/diagnosis.rb
+- lib/rpeft/directory.rb
+- lib/rpeft/errors.rb
+- lib/rpeft/generation.rb
+- lib/rpeft/lora.rb
+- lib/rpeft/lora/adapter.rb
+- lib/rpeft/messages.rb
+- lib/rpeft/model.rb
+- lib/rpeft/version.rb
+- python/rpeft_backend/__init__.py
+- python/rpeft_backend/_chat.py
+- python/rpeft_backend/_data.py
+- python/rpeft_backend/_device.py
+- python/rpeft_backend/_diagnostics.py
+- python/rpeft_backend/_errors.py
+- python/rpeft_backend/_generate.py
+- python/rpeft_backend/_merge.py
+- python/rpeft_backend/_models.py
+- python/rpeft_backend/_training.py
+- python/rpeft_backend/_versions.py
+homepage: https://github.com/koic/rpeft
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/koic/rpeft
+  changelog_uri: https://github.com/koic/rpeft/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: LoRA fine-tuning for LLMs from Ruby.
+test_files: []