wisent 0.1.1__py3-none-any.whl → 0.5.1__py3-none-any.whl

wisent/cli/steering_methods/steering_rotator.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+import importlib
+import importlib.util
+import inspect
+import logging
+import pkgutil
+from pathlib import Path
+from typing import Any, Type
+
+from wisent_guard.core.steering_methods.core.atoms import BaseSteeringError, BaseSteeringMethod
+from wisent_guard.core.contrastive_pairs.core.set import ContrastivePairSet
+
+from wisent_guard.core.activations.core.atoms import LayerActivations
+
+__all__ = [
+    "SteeringMethodRotator",
+]
+
+logger = logging.getLogger(__name__)
+
+class SteeringMethodRotator:
+    """Discover/select a steering method and train it on a ContrastivePairSet."""
+
+    def __init__(
+        self,
+        method: str | BaseSteeringMethod | Type[BaseSteeringMethod] | None = None,
+        methods_location: str | Path = "wisent_guard.core.steering_methods.methods",
+        autoload: bool = True,
+        **default_method_kwargs: Any,
+    ) -> None:
+        if autoload:
+            self.discover_methods(methods_location)
+        self._method = self._resolve_method(method, **default_method_kwargs)
+
+    @staticmethod
+    def discover_methods(location: str | Path) -> None:
+        loc_path = Path(str(location))
+        if loc_path.exists() and loc_path.is_dir():
+            for py in loc_path.glob("*.py"):
+                if py.name.startswith("_"):
+                    continue
+                mod_name = f"_dyn_steering_{py.stem}"
+                spec = importlib.util.spec_from_file_location(mod_name, py)
+                if spec and spec.loader:
+                    module = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(module)  
+            return
+
+        if not isinstance(location, str):
+            raise BaseSteeringError(f"Invalid methods location: {location!r}")
+
+        try:
+            pkg = importlib.import_module(location)
+        except ModuleNotFoundError as exc:
+            raise BaseSteeringError(f"Cannot import steering package {location!r}.") from exc
+
+        search_paths = list(getattr(pkg, "__path__", [])) or [Path(getattr(pkg, "__file__", "")).parent.as_posix()]
+        for _, name, _ in pkgutil.iter_modules(search_paths):
+            if name.startswith("_"):
+                continue
+            importlib.import_module(f"{location}.{name}")
+
+    @staticmethod
+    def list_methods() -> list[dict[str, Any]]:
+        return [
+            {
+                "name": name,
+                "description": getattr(cls, "description", ""),
+                "class": f"{cls.__module__}.{cls.__name__}",
+            }
+            for name, cls in sorted(BaseSteeringMethod.list_registered().items(), key=lambda kv: kv[0])
+        ]
+
+    @staticmethod
+    def _resolve_method(
+        method: str | BaseSteeringMethod | Type[BaseSteeringMethod] | None,
+        **kwargs: Any,
+    ) -> BaseSteeringMethod:
+        if method is None:
+            reg = BaseSteeringMethod.list_registered()
+            if not reg:
+                raise BaseSteeringError("No steering methods registered.")
+            first = next(iter(sorted(reg.items(), key=lambda kv: kv[0])))[1]
+            return first(**kwargs)
+        if isinstance(method, BaseSteeringMethod):
+            method.kwargs = {**kwargs, **method.kwargs}
+            return method
+        if inspect.isclass(method) and issubclass(method, BaseSteeringMethod):
+            return method(**kwargs)
+        if isinstance(method, str):
+            return BaseSteeringMethod.get(method)(**kwargs)
+        raise TypeError("method must be None, str name, BaseSteeringMethod instance, or subclass.")
+    
+    def use(self, method: str | BaseSteeringMethod | Type[BaseSteeringMethod], **kwargs: Any) -> None:
+        self._method = self._resolve_method(method, **kwargs)
+
+    def train(self, pair_set: ContrastivePairSet, **overrides: Any) -> LayerActivations:
+        old = dict(self._method.kwargs)
+        try:
+            self._method.kwargs = {**old, **overrides}
+            return self._method.train(pair_set)
+        finally:
+            self._method.kwargs = old
+
+if __name__ == "__main__":
+    rot = SteeringMethodRotator()
+    print("Available steering methods:")
+    for m in rot.list_methods():
+        print(f" - {m['name']}: {m['description']} ({m['class']})")

wisent/cli/wisent_cli/commands/help_cmd.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+import shlex
+from typing import Optional
+import typer
+
+__all__ = ["app", "help_command"]
+
+app = typer.Typer(help="Human-friendly help router")
+
+def _run_cli_line(line: str) -> None:
+    from typer.main import get_command
+    from wisent_guard.cli.wisent_cli.main import app as root_app
+    click_cmd = get_command(root_app)
+    args = shlex.split(line)
+    try:
+        click_cmd.main(args=args, standalone_mode=False, prog_name="wisent")
+    except SystemExit as e:
+        if e.code not in (0, None):
+            raise
+
+@app.command("help")
+def help_command(topic: Optional[str] = typer.Argument(None), name: Optional[str] = typer.Argument(None)):
+    """
+    Examples:
+      wisent help train
+      wisent help method caa
+      wisent help loader custom
+      wisent help list-methods
+    """
+    t = (topic or "").strip().lower()
+
+    if t in {"", "app", "main"}:
+        _run_cli_line("--help")
+        return
+
+    passthrough = {"train", "list-methods", "list-loaders", "list-aggregations", "explain", "instructions", "start"}
+    if t in passthrough:
+        _run_cli_line(f"{t} --help")
+        return
+
+    if t in {"method", "methods"} and name:
+        _run_cli_line(f"explain --method {shlex.quote(name)}")
+        return
+    if t in {"loader", "loaders"} and name:
+        _run_cli_line(f"explain --loader {shlex.quote(name)}")
+        _run_cli_line(f"loader-args {shlex.quote(name)}")
+        return
+    if t in {"aggregation", "agg", "aggregations"} and name:
+        _run_cli_line(f"explain --aggregation {shlex.quote(name)}")
+        return
+
+    _run_cli_line("--help")

wisent/cli/wisent_cli/commands/listing.py

@@ -0,0 +1,154 @@
+from __future__ import annotations
+import inspect
+from typing import Optional
+
+import typer
+
+from wisent_guard.cli.wisent_cli.ui import echo
+from wisent_guard.cli.wisent_cli.util import aggregations as aggs
+
+try:
+    from rich.table import Table
+    from rich.panel import Panel
+    HAS_RICH = True
+except Exception:
+    HAS_RICH = False
+
+app = typer.Typer(help="Listing, discovery, and explanation commands")
+
+
+@app.command("list-aggregations")
+def list_aggregations():
+    if HAS_RICH:
+        t = Table(title="Aggregation Strategies")
+        t.add_column("Name", style="bold")
+        t.add_column("Description")
+        for k, desc in aggs.descriptions().items():
+            t.add_row(k.name.lower(), desc)
+        echo(t)
+    else:
+        for k, desc in aggs.descriptions().items():
+            print(f"- {k.name.lower():22s} : {desc}")
+
+
+@app.command("list-methods")
+def list_methods():
+    from wisent_guard.cli.steering_methods.steering_rotator import SteeringMethodRotator  # type: ignore
+    rot = SteeringMethodRotator()
+    methods = rot.list_methods()
+    if not methods:
+        typer.echo("No steering methods registered.")
+        raise typer.Exit(code=1)
+    if HAS_RICH:
+        t = Table(title="Registered Steering Methods")
+        t.add_column("Name", style="bold")
+        t.add_column("Description")
+        t.add_column("Class")
+        for m in methods:
+            t.add_row(m["name"], m["description"], m["class"])
+        echo(t)
+    else:
+        for m in methods:
+            print(f"- {m['name']}: {m['description']} ({m['class']})")
+
+
+@app.command("list-loaders")
+def list_loaders(
+    loaders_location: Optional[str] = typer.Option(None, help="Package path or directory containing data loader modules"),
+    scope_prefix: Optional[str] = typer.Option(None, help="Limit list to module path prefix"),
+):
+    from wisent_guard.cli.data_loaders.data_loader_rotator import DataLoaderRotator  # type: ignore
+    if loaders_location:
+        DataLoaderRotator.discover_loaders(loaders_location)
+    loaders = DataLoaderRotator.list_loaders(scope_prefix=scope_prefix)
+    if not loaders:
+        typer.echo("No data loaders found.")
+        raise typer.Exit(code=1)
+    if HAS_RICH:
+        t = Table(title="Registered Data Loaders")
+        t.add_column("Name", style="bold")
+        t.add_column("Description")
+        t.add_column("Class")
+        for l in loaders:
+            t.add_row(l["name"], l["description"], l["class"])
+        echo(t)
+    else:
+        for l in loaders:
+            print(f"- {l['name']}: {l['description']} ({l['class']})")
+
+
+@app.command("explain")
+def explain(
+    method: Optional[str] = typer.Option(None, help="Steering method to describe"),
+    loader: Optional[str] = typer.Option(None, help="Data loader to describe"),
+    loaders_location: Optional[str] = typer.Option(None, help="Where to discover data loaders"),
+    aggregation: Optional[str] = typer.Option(None, help="Aggregation to describe"),
+):
+    from wisent_guard.cli.data_loaders.data_loader_rotator import DataLoaderRotator  # type: ignore
+    from wisent_guard.cli.steering_methods.steering_rotator import SteeringMethodRotator  # type: ignore
+
+    if loaders_location:
+        DataLoaderRotator.discover_loaders(loaders_location)
+
+    if method:
+        m = SteeringMethodRotator._resolve_method(method)
+        doc = (getattr(type(m), "__doc__", None) or "No docstring.").strip()
+        if HAS_RICH:
+            echo(Panel(doc, title=f"Method: {getattr(m, 'name', type(m).__name__)}"))
+        else:
+            print(doc)
+
+    if loader:
+        reg = DataLoaderRotator.list_loaders()
+        match = next((x for x in reg if x["name"].lower() == loader.lower()), None)
+        if match:
+            desc = (match.get("description") or "No description.").strip()
+            if HAS_RICH:
+                echo(Panel(desc, title=f"Loader: {loader}"))
+            else:
+                print(desc)
+        else:
+            typer.echo(f"Unknown loader: {loader}")
+
+    if aggregation:
+        agg = aggs.pick(aggregation)
+        desc = aggs.descriptions().get(agg, "No description.")
+        if HAS_RICH:
+            from rich.panel import Panel
+            echo(Panel(desc, title=f"Aggregation: {aggregation}"))
+        else:
+            print(desc)
+
+
+@app.command("loader-args")
+def loader_args(
+    name: str = typer.Argument(..., help="Loader name, e.g. 'custom'"),
+    loaders_location: Optional[str] = typer.Option(None, help="Where to discover data loaders"),
+):
+    """
+    Show the exact arguments accepted by the loader's `load(...)` method.
+    Useful so users know precisely what to pass (e.g., for `custom`:
+    `path, split_ratio, seed, training_limit, testing_limit`).
+    """
+    from wisent_guard.cli.data_loaders.data_loader_rotator import DataLoaderRotator  # type: ignore
+    if loaders_location:
+        DataLoaderRotator.discover_loaders(loaders_location)
+    rot = DataLoaderRotator(loader=name, loaders_location=loaders_location or "wisent_guard.core.data_loaders.loaders")
+    # Best-effort introspection
+    target = None
+    for cand in (getattr(rot, "_loader", None), rot):
+        if cand is None:
+            continue
+        if hasattr(cand, "load"):
+            target = cand.load
+            break
+    if target is None:
+        typer.echo("Could not introspect loader signature.")
+        raise typer.Exit(code=1)
+
+    sig = inspect.signature(target)
+    if HAS_RICH:
+        from rich.panel import Panel
+        echo(Panel(f"{name}.load{sig}", title="Loader load(...) signature"))
+    else:
+        print(f"{name}.load{sig}")

wisent/cli/wisent_cli/commands/train_cmd.py

@@ -0,0 +1,322 @@
+from __future__ import annotations
+import json
+import os
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import typer
+
+from wisent_guard.cli.wisent_cli.ui import echo
+from wisent_guard.cli.wisent_cli.util import aggregations as aggs
+from wisent_guard.cli.wisent_cli.util.parsing import (
+    parse_natural_tokens, parse_kv, parse_layers, to_bool, DTYPE_MAP,
+)
+
+try:
+    from rich.table import Table
+    from rich.panel import Panel
+    from rich.syntax import Syntax
+    HAS_RICH = True
+except Exception:
+    HAS_RICH = False
+
+__all__ = ["app", "train"]
+
+app = typer.Typer(help="Training workflow")
+
+def _resolve_method(method_name: Optional[str], methods_location: Optional[str]):
+    from wisent_guard.cli.steering_methods.steering_rotator import SteeringMethodRotator  # type: ignore
+    # Best effort discovery if available
+    try:
+        if methods_location and hasattr(SteeringMethodRotator, "discover_methods"):
+            SteeringMethodRotator.discover_methods(methods_location)  # type: ignore[attr-defined]
+    except Exception:
+        pass
+
+    rot = SteeringMethodRotator()
+    if method_name:
+        # Case-insensitive match from registry
+        registry = {m["name"].lower(): m["name"] for m in rot.list_methods()}
+        real = registry.get(method_name.lower(), method_name)
+        try:
+            rot.use(real)
+            inst = getattr(rot, "_method", None)
+            if inst is not None:
+                return inst
+        except Exception:
+            pass
+        # Fallback to private resolver
+        try:
+            return SteeringMethodRotator._resolve_method(real)
+        except Exception as ex:
+            raise typer.BadParameter(f"Unknown steering method: {method_name!r}") from ex
+
+    # No name provided -> default to first or 'caa' if present
+    names = [m["name"] for m in rot.list_methods()]
+    if "caa" in [n.lower() for n in names]:
+        rot.use("caa")
+        return getattr(rot, "_method", SteeringMethodRotator._resolve_method("caa"))
+    if not names:
+        raise typer.BadParameter("No steering methods registered.")
+    rot.use(names[0])
+    return getattr(rot, "_method", SteeringMethodRotator._resolve_method(names[0]))
+
+
+def _show_plan(
+    *,
+    model: str,
+    loader: Optional[str],
+    loaders_location: Optional[str],
+    loader_kwargs: Dict[str, object],
+    method_name: Optional[str],
+    method_kwargs: Dict[str, object],
+    layers: Optional[str],
+    aggregation_name: str,
+    store_device: str,
+    dtype: Optional[str],
+    return_full_sequence: bool,
+    normalize_layers: bool,
+    save_dir: Optional[Path],
+) -> None:
+    plan = {
+        "Model": model,
+        "Data loader": loader or "(default)",
+        "Loaders location": loaders_location or "(auto)",
+        "Loader kwargs": loader_kwargs or {},
+        "Method": method_name or "(resolved automatically)",
+        "Method kwargs": method_kwargs or {},
+        "Layers": layers or "(all)",
+        "Aggregation": aggregation_name,
+        "Return full sequence": return_full_sequence,
+        "Normalize layers": normalize_layers,
+        "Store device": store_device,
+        "Dtype": dtype or "(unchanged)",
+        "Save dir": str(save_dir) if save_dir else "(none)",
+    }
+
+    code = f"""
+# Example: Training steering vectors (auto-generated plan)
+from wisent_guard.core.trainers.steering_trainer import WisentSteeringTrainer
+from wisent_guard.core.models.wisent_model import WisentModel
+from wisent_guard.cli.data_loaders.data_loader_rotator import DataLoaderRotator
+from wisent_guard.cli.steering_methods.steering_rotator import SteeringMethodRotator
+from wisent_guard.core.activations.core.atoms import ActivationAggregationStrategy
+
+# 1) Model
+model = WisentModel(model_name={model!r}, layers={{}}, device={store_device!r})
+
+# 2) Data loader
+rot = DataLoaderRotator(loader={loader!r}, loaders_location={loaders_location!r})
+load = rot.load(**{json.dumps(loader_kwargs)})
+
+# 3) Method
+method = SteeringMethodRotator._resolve_method({(method_name or 'caa')!r})
+
+# 4) Trainer
+trainer = WisentSteeringTrainer(model=model, pair_set=load["train_qa_pairs"], steering_method=method,
+                                store_device={store_device!r}, dtype={dtype!r})
+
+# 5) Train
+result = trainer.run(
+    layers_spec={layers!r},
+    method_kwargs={json.dumps(method_kwargs)},
+    aggregation=ActivationAggregationStrategy.{aggs.pick(aggregation_name).name},
+    return_full_sequence={return_full_sequence!r},
+    normalize_layers={normalize_layers!r},
+    save_dir={str(save_dir) if save_dir else None!r},
+)
+""".strip()
+
+    if HAS_RICH:
+        t = Table(title="Execution Plan")
+        t.add_column("Key", style="bold", no_wrap=True)
+        t.add_column("Value")
+        for k, v in plan.items():
+            t.add_row(k, json.dumps(v) if isinstance(v, (dict, list)) else str(v))
+        echo(Panel(t, expand=False))
+        echo(Panel(Syntax(code, "python", word_wrap=False), title="Code Preview", expand=False))
+    else:
+        print(json.dumps(plan, indent=2))
+        print("\n" + code)
+
+
+@app.command("train", context_settings={"ignore_unknown_options": True, "allow_extra_args": True})
+def train(ctx: typer.Context, params: List[str] = typer.Argument(None)):
+    """
+    Natural (no-dash) usage examples:
+
+      wisent train model meta-llama/Llama-3.2-1B-Instruct loader custom path ./custom.json training_limit 5 method caa
+
+      wisent train interactive true
+
+    See `wisent loader-args custom` to view the exact loader arguments.
+    """
+    # Lazy imports
+    from wisent_guard.cli.data_loaders.data_loader_rotator import DataLoaderRotator  # type: ignore
+    from wisent_guard.core.models.wisent_model import WisentModel  # type: ignore
+    from wisent_guard.core.trainers.steering_trainer import WisentSteeringTrainer  # type: ignore
+
+    tokens = list(params or []) + list(ctx.args or [])
+    top, loader_kv_raw, method_kv_raw = parse_natural_tokens(tokens)
+
+    # Core args
+    model = top.get("model")
+    if not model:
+        raise typer.BadParameter("Please specify a model (e.g. `train model meta-llama/Llama-3.2-1B-Instruct`) or use `interactive true`.")
+
+    loader = top.get("loader")
+    loaders_location = top.get("loaders_location")
+    methods_location = top.get("methods_location")
+    method_name = top.get("method")
+
+    layers = parse_layers(top.get("layers")) if top.get("layers") else None
+    aggregation_name = (top.get("aggregation") or "continuation_token").lower()
+    store_device = top.get("device") or top.get("store_device") or "cpu"
+    dtype = top.get("dtype")
+    save_dir = Path(top["save_dir"]) if top.get("save_dir") else None
+    return_full_sequence = to_bool(top.get("return_full_sequence", "false")) if "return_full_sequence" in top else False
+    normalize_layers = to_bool(top.get("normalize_layers", "false")) if "normalize_layers" in top else False
+    interactive = to_bool(top.get("interactive", "false")) if "interactive" in top else False
+    plan_only = to_bool(top.get("plan-only", top.get("plan_only", "false"))) if ( "plan-only" in top or "plan_only" in top ) else False
+    confirm = to_bool(top.get("confirm", "true")) if "confirm" in top else True
+
+    # Convert kwargs
+    loader_kwargs = parse_kv([f"{k}={v}" for k, v in loader_kv_raw.items()])
+    method_kwargs = parse_kv([f"{k}={v}" for k, v in method_kv_raw.items()])
+
+    # Interactive wizard
+    if interactive:
+        if loaders_location:
+            DataLoaderRotator.discover_loaders(loaders_location)
+        if not loader:
+            options = [d["name"] for d in DataLoaderRotator.list_loaders()]
+            loader = typer.prompt("Choose data loader", default=(options[0] if options else "custom"))
+        if loader and loader.lower() == "custom":
+            echo(Panel(
+                "[b]Custom loader arguments[/]\n\n"
+                "• path (str)  [required]\n"
+                "• split_ratio (float | None)\n"
+                "• seed (int | None)\n"
+                "• training_limit (int | None)\n"
+                "• testing_limit (int | None)",
+                title="custom.load(...)",
+            ) if HAS_RICH else
+                None
+            )
+            if "path" not in loader_kwargs:
+                loader_kwargs["path"] = typer.prompt("Path to dataset JSON (required)")
+            for name, cast, default in [
+                ("split_ratio", float, ""),
+                ("seed", int, ""),
+                ("training_limit", int, ""),
+                ("testing_limit", int, ""),
+            ]:
+                if name not in loader_kwargs:
+                    val = typer.prompt(f"{name} (optional)", default=default)
+                    if str(val).strip() != "":
+                        try:
+                            loader_kwargs[name] = cast(val)
+                        except Exception:
+                            loader_kwargs[name] = val
+        if not method_name:
+            method_name = typer.prompt("Choose steering method (see list-methods)", default="caa")
+        if layers is None:
+            layers = parse_layers(typer.prompt("Layers (e.g., '10..12', '5,7,9' or leave empty for all)", default="") or None)
+        if "aggregation" not in top:
+            aggregation_name = typer.prompt("Aggregation (see list-aggregations)", default="continuation_token")
+        if "dtype" not in top:
+            dtype = typer.prompt("Activation dtype (float32/float16/bfloat16 or blank)", default="") or None
+        if "device" not in top and "store_device" not in top:
+            store_device = typer.prompt("Device to store activations on (cpu / cuda / cuda:0 / ...)", default="cpu")
+        if "normalize_layers" not in top:
+            normalize_layers = typer.confirm("Normalize activations per layer?", default=True)
+        if "return_full_sequence" not in top:
+            return_full_sequence = typer.confirm("Return full [T,H] sequence per layer?", default=False)
+        if "save_dir" not in top:
+            default_out = os.path.abspath("./steering_output")
+            p = typer.prompt("Save directory for artifacts (blank to skip saving)", default=default_out)
+            if p.strip():
+                save_dir = Path(p)
+        if "plan-only" not in top and "plan_only" not in top:
+            plan_only = typer.confirm("Only show the plan and code preview?", default=False)
+        if "confirm" not in top:
+            confirm = typer.confirm("Confirm before running?", default=True)
+
+    # Validate dtype
+    if dtype not in DTYPE_MAP:
+        raise typer.BadParameter("dtype must be one of: float32, float16, bfloat16")
+
+    # Validate aggregation
+    try:
+        agg = aggs.pick(aggregation_name)
+    except ValueError as ex:
+        raise typer.BadParameter(str(ex)) from ex
+
+    # Plan
+    _show_plan(
+        model=model,
+        loader=loader,
+        loaders_location=loaders_location,
+        loader_kwargs=loader_kwargs,
+        method_name=method_name,
+        method_kwargs=method_kwargs,
+        layers=layers,
+        aggregation_name=aggregation_name,
+        store_device=store_device,
+        dtype=dtype,
+        return_full_sequence=return_full_sequence,
+        normalize_layers=normalize_layers,
+        save_dir=save_dir,
+    )
+
+    if plan_only:
+        return
+
+    if confirm and not typer.confirm("Proceed with training?", default=True):
+        typer.echo("Aborted.")
+        raise typer.Exit(code=1)
+
+    # -- Model -----------------------------------------------------------------
+    typer.echo(f"[+] Loading model: {model}")
+    from wisent_guard.core.models.wisent_model import WisentModel  # type: ignore
+    wmodel = WisentModel(model_name=model, layers={}, device=store_device)
+
+    # -- Data loader -----------------------------------------------------------
+    from wisent_guard.cli.data_loaders.data_loader_rotator import DataLoaderRotator  # type: ignore
+    if loaders_location:
+        DataLoaderRotator.discover_loaders(loaders_location)
+    dl_rot = DataLoaderRotator(loader=loader, loaders_location=loaders_location or "wisent_guard.core.data_loaders.loaders")
+    typer.echo(f"[+] Using data loader: {loader or '(default)'}")
+    load_result = dl_rot.load(**loader_kwargs)
+    pair_set = load_result["train_qa_pairs"]
+    typer.echo(f"[+] Loaded training pairs: {len(pair_set)} (task_type={load_result['task_type']})")
+
+    # -- Steering method -------------------------------------------------------
+    method_inst = _resolve_method(method_name, methods_location)
+    name_shown = getattr(method_inst, "name", type(method_inst).__name__)
+    typer.echo(f"[+] Steering method: {name_shown}")
+
+    # -- Trainer ---------------------------------------------------------------
+    from wisent_guard.core.trainers.steering_trainer import WisentSteeringTrainer  # type: ignore
+    torch_dtype = None if dtype is None else __import__("torch").__dict__[DTYPE_MAP[dtype]]
+    trainer = WisentSteeringTrainer(
+        model=wmodel,
+        pair_set=pair_set,
+        steering_method=method_inst,
+        store_device=store_device,
+        dtype=torch_dtype,
+    )
+
+    result = trainer.run(
+        layers_spec=layers,
+        method_kwargs=method_kwargs,
+        aggregation=agg,
+        return_full_sequence=return_full_sequence,
+        normalize_layers=normalize_layers,
+        save_dir=save_dir,
+    )
+
+    typer.echo("\n=== Training Summary ===")
+    typer.echo(json.dumps(result.metadata, indent=2))
+    if save_dir is not None:
+        typer.echo(f"\nArtifacts saved in: {Path(save_dir).resolve()}\n")