hud-python 0.4.45__py3-none-any.whl → 0.5.1__py3-none-any.whl

hud/cli/rl/__init__.py

@@ -1,180 +0,0 @@
-"""RL training command for HUD CLI."""
-
-from __future__ import annotations
-
-import logging
-import os
-from typing import TYPE_CHECKING
-
-import typer
-from rich.console import Console
-
-from hud.cli.utils.tasks import find_tasks_file
-from hud.utils.hud_console import hud_console
-
-console = Console()
-
-if TYPE_CHECKING:
-    from pathlib import Path
-
-
-def rl_command(
-    tasks_file: str | None = typer.Argument(
-        None,
-        help="Path to tasks file (JSON/JSONL) or HuggingFace dataset name",
-    ),
-    model: str | None = typer.Argument(
-        None,
-        help="Model to train from https://hud.so/models (default: interactive selection)",
-    ),
-    config_file: Path | None = typer.Option(  # noqa: B008
-        None,
-        "--config",
-        "-c",
-        help="Path to existing configuration file",
-    ),
-    output_dir: str = typer.Option(
-        "/checkpoints",
-        "--output-dir",
-        "-o",
-        help="Output directory for checkpoints",
-    ),
-    restart: bool = typer.Option(
-        False,
-        "--restart",
-        help="Restart the vLLM server before training",
-    ),
-    verbose: bool = typer.Option(
-        False,
-        "--verbose",
-        "-v",
-        help="Enable verbose output",
-    ),
-    # DDP options
-    no_ddp: bool = typer.Option(
-        False,
-        "--no-ddp",
-        help="Disable DDP even with multiple GPUs",
-    ),
-    ddp_gpus: str | None = typer.Option(
-        None,
-        "--ddp-gpus",
-        help="Specific GPUs for DDP (e.g., '0,1,2,3')",
-    ),
-    vllm_gpu: int | None = typer.Option(
-        None,
-        "--vllm-gpu",
-        help="Specific GPU for vLLM server",
-    ),
-    # Execution mode options
-    local: bool = typer.Option(
-        False,
-        "--local",
-        help="Run training locally instead of using remote API server",
-    ),
-    yes: bool = typer.Option(
-        False,
-        "--yes",
-        "-y",
-        help="Auto-accept all prompts and use defaults (lazy mode)",
-    ),
-    vllm_gpu_count: int = typer.Option(
-        None,
-        "--vllm-gpu-count",
-        help="Number of GPUs for vLLM server",
-    ),
-    skip_vllm_startup: bool = typer.Option(
-        False,
-        "--skip-vllm-startup",
-        help="Skip local vLLM server startup (for internal use)",
-    ),
-) -> None:
-    """Run GRPO reinforcement learning training on tasks."""
-    # Configure logging based on verbose flag BEFORE any output
-    if not verbose:
-        os.environ["HUD_LOG_LEVEL"] = "WARNING"
-        logging.basicConfig(level=logging.WARNING, force=True)
-        root_logger = logging.getLogger()
-        root_logger.setLevel(logging.WARNING)
-
-        # Suppress INFO logs from various components
-        for logger_name in [
-            "httpx",
-            "hud.agents",
-            "hud.utils.design",
-            "hud",
-            "asyncio",
-            "transformers",
-        ]:
-            logging.getLogger(logger_name).setLevel(logging.WARNING)
-        logging.getLogger("hud.agents.base").setLevel(logging.WARNING)
-    else:
-        logging.basicConfig(level=logging.INFO)
-
-    hud_console.header("HUD RL Training")
-
-    # Determine execution mode
-    use_remote = not local
-
-    if not tasks_file:
-        tasks_file = find_tasks_file(tasks_file)
-        if not tasks_file:
-            hud_console.warning("No tasks file found in current directory")
-            hud_console.hint(
-                "Download a HF dataset using `hud get <dataset_name>` (e.g., `hud get hud-evals/2048-basic`)"  # noqa: E501
-            )
-            hud_console.hint("or create a tasks file manually.")
-            raise typer.Exit(1)
-
-    # If user ran bare `hud rl`, guide them through remote task conversion flow
-    # before proceeding (remote only)
-    if use_remote:
-        try:
-            from hud.cli.flows.tasks import convert_tasks_to_remote
-
-            console.print("[cyan]Preparing remote training tasks...[/cyan]")
-            tasks_file = convert_tasks_to_remote(tasks_file)
-        except typer.Exit:
-            raise
-        except Exception as e:
-            hud_console.warning(f"[red]Tasks file is not valid for remote training: {e!s}[/red]")
-            hud_console.hint("Either ensure the tasks file has remote urls")
-            hud_console.hint("Or rerun `hud rl` within an environment directory")
-            raise typer.Exit(1) from e
-
-        try:
-            from .remote_runner import run_remote_training
-
-            run_remote_training(
-                tasks_file=tasks_file,
-                model=model,
-                config_file=config_file,
-                output_dir=output_dir,
-                vllm_gpu_count=vllm_gpu_count,
-                yes=yes,
-            )
-            return
-        except Exception as e:
-            console.print(f"[red]❌ Remote training failed: {e!s}[/red]")
-            raise typer.Exit(1) from e
-
-    # Local execution flow delegated to local_runner (imports heavy deps lazily)
-    from .local_runner import run_local_training
-
-    run_local_training(
-        tasks_file=tasks_file,
-        model=model,
-        config_file=config_file,
-        output_dir=output_dir,
-        yes=yes,
-        restart=restart,
-        verbose=verbose,
-        no_ddp=no_ddp,
-        ddp_gpus=ddp_gpus,
-        vllm_gpu=vllm_gpu,
-        skip_vllm_startup=skip_vllm_startup,
-    )
-
-
-# Export the command function
-__all__ = ["rl_command"]

hud/cli/rl/config.py

@@ -1,101 +0,0 @@
-"""Configuration generation and management for RL training."""
-
-from __future__ import annotations
-
-import json
-from typing import TYPE_CHECKING, Any
-
-from rich.console import Console
-
-from hud.rl.config import Config, validate_vl_model
-from hud.utils.hud_console import hud_console
-
-from .display import display_preset_table
-from .presets import estimate_memory_usage
-
-if TYPE_CHECKING:
-    from pathlib import Path
-console = Console()
-
-
-def generate_config_interactive(
-    model_name: str,
-    presets: list[dict[str, Any]],
-    yes: bool = False,
-) -> tuple[Config, float]:
-    """Generate RL training configuration interactively."""
-    # Validate model is a VL model
-    validate_vl_model(model_name)
-
-    # Display preset options
-    if not yes:
-        display_preset_table(presets, 80.0)  # Assuming A100 80GB
-
-    # Let user select preset
-    if yes:
-        # Use default preset (Balanced if available, otherwise first)
-        preset_choice = 1 if len(presets) > 1 else 0
-        selected_preset = presets[preset_choice]
-        hud_console.info(f"Auto-selecting preset: {selected_preset['name']} (--yes mode)")
-    else:
-        preset_choice = hud_console.select(
-            "Select a training configuration preset:",
-            choices=[{"name": p["name"], "value": i} for i, p in enumerate(presets)],
-            default=1 if len(presets) > 1 else 0,  # Default to "Balanced" if available
-        )
-        selected_preset = presets[preset_choice]  # type: ignore
-
-    # Use preset values directly
-    max_steps_per_episode = selected_preset["max_steps_per_episode"]
-
-    # Calculate memory estimate
-    max_pixels = 256 * 28 * 28
-    estimated_memory = estimate_memory_usage(
-        selected_preset["mini_batch_size"],
-        max_steps_per_episode,
-        selected_preset["max_new_tokens"],
-        max_pixels,
-    )
-
-    config_adds = {
-        "actor": {
-            "max_new_tokens": selected_preset["max_new_tokens"],
-            "max_parallel_episodes": selected_preset["batch_size"],
-            "max_steps_per_episode": selected_preset["max_steps_per_episode"],
-            "force_tool_choice": True,
-        },
-        "training": {
-            "mini_batch_size": selected_preset["mini_batch_size"],
-            "group_size": selected_preset["group_size"],
-            "batch_size": selected_preset["batch_size"],
-            "lr": selected_preset["lr"],
-            "epochs": selected_preset["epochs"],
-        },
-        "verbose": True,
-    }
-
-    # Create config
-    config = Config.from_dict(config_adds)
-
-    return config, estimated_memory
-
-
-def save_config(config: Config, path: Path) -> None:
-    """Save configuration to a JSON file."""
-    config_dict = config.to_dict()
-
-    with open(path, "w", encoding="utf-8") as f:
-        json.dump(config_dict, f, indent=2)
-        f.write("\n")  # Add newline at end of file
-
-    if not path.name.startswith("."):  # Don't show message for temp files
-        console.print(f"[green]✅ Configuration saved to {path}[/green]")
-
-
-def load_config(path: Path) -> Config:
-    """Load configuration from a JSON file."""
-    with open(path, encoding="utf-8") as f:
-        data = json.load(f)
-
-    # Use Config.from_dict which handles missing fields gracefully
-    return Config.from_dict(data)

hud/cli/rl/display.py

@@ -1,133 +0,0 @@
-"""Display utilities for RL training configuration."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any
-
-from rich.console import Console
-from rich.table import Table
-
-if TYPE_CHECKING:
-    from hud.rl.config import Config
-
-console = Console()
-
-
-def display_gpu_info(gpu_info: dict[str, Any]) -> None:
-    """Display GPU information in a table."""
-    if not gpu_info["available"]:
-        console.print(f"[red]❌ CUDA not available: {gpu_info.get('error', 'Unknown error')}[/red]")
-        return
-
-    gpu_table = Table(title="🖥️  Available GPUs", title_style="bold cyan")
-    gpu_table.add_column("Index", style="yellow")
-    gpu_table.add_column("Name", style="cyan")
-    gpu_table.add_column("Memory", style="green")
-
-    for device in gpu_info["devices"]:
-        gpu_table.add_row(f"GPU {device['index']}", device["name"], f"{device['memory_gb']:.1f} GB")
-
-    console.print(gpu_table)
-
-
-def display_preset_table(presets: list[dict[str, Any]], gpu_memory_gb: float) -> None:
-    """Display training configuration presets in a table."""
-    preset_table = Table(title="📊 Training Configuration Presets", title_style="bold cyan")
-    preset_table.add_column("Option", style="yellow")
-    preset_table.add_column("Steps", style="cyan")
-    preset_table.add_column("Mini-batch", style="cyan")
-    preset_table.add_column("Group", style="cyan")
-    preset_table.add_column("Episodes/batch", style="cyan")
-
-    # Add time columns for A100
-    if gpu_memory_gb >= 40:
-        preset_table.add_column("Tasks/hour", style="green")
-        preset_table.add_column("Updates/hour", style="green")
-
-    for i, preset in enumerate(presets):
-        row = [
-            f"{i + 1}. {preset['name']}",
-            str(preset["max_steps_per_episode"]),
-            str(preset["mini_batch_size"]),
-            str(preset["group_size"]),
-            str(preset["batch_size"]),
-        ]
-        if "tasks_per_hour" in preset:
-            row.extend(
-                [
-                    str(preset["tasks_per_hour"]),
-                    str(preset["steps_per_hour"]),
-                ]
-            )
-        preset_table.add_row(*row)
-
-    console.print("\n")
-    console.print(preset_table)
-    console.print("\n")
-
-
-def display_config_summary(
-    config: Config, tasks_count: int, gpu_info: dict[str, Any], estimated_memory: float
-) -> None:
-    """Display comprehensive configuration summary for review."""
-    console.print("\n[bold cyan]📋 RL Training Configuration Summary[/bold cyan]\n")
-
-    # GPU Information
-    if gpu_info["available"]:
-        gpu_table = Table(title="🖥️  GPU Information", title_style="bold yellow")
-        gpu_table.add_column("Property", style="cyan")
-        gpu_table.add_column("Value", style="green")
-
-        device = gpu_info["devices"][0]  # Primary GPU
-        gpu_table.add_row("GPU 0", device["name"])
-        gpu_table.add_row("Memory", f"{device['memory_gb']:.1f} GB")
-        gpu_table.add_row("Compute Capability", "8.0")  # Assuming A100
-
-        console.print(gpu_table)
-
-    # Model Configuration
-    model_table = Table(title="🤖 Model Configuration", title_style="bold yellow")
-    model_table.add_column("Parameter", style="cyan")
-    model_table.add_column("Value", style="green")
-
-    model_table.add_row("Base Model", config.model.base_model)
-    model_table.add_row("LoRA Rank (r)", str(config.model.lora_r))
-    model_table.add_row("LoRA Alpha", str(config.model.lora_alpha))
-    model_table.add_row("LoRA Dropout", str(config.model.lora_dropout))
-
-    console.print(model_table)
-
-    # Training Configuration
-    training_table = Table(title="🎯 Training Configuration", title_style="bold yellow")
-    training_table.add_column("Parameter", style="cyan")
-    training_table.add_column("Value", style="green")
-
-    training_table.add_row("Tasks Count", str(tasks_count))
-    training_table.add_row("Learning Rate", f"{config.training.lr:.1e}")
-    training_table.add_row("Epochs", str(config.training.epochs))
-    training_table.add_row("Mini Batch Size", str(config.training.mini_batch_size))
-    training_table.add_row("Batch Size", str(config.training.batch_size))
-    training_table.add_row("Group Size", str(config.training.group_size))
-    training_table.add_row("Training Steps", str(config.training.training_steps))
-    training_table.add_row("Max Parallel Episodes", str(config.actor.max_parallel_episodes))
-
-    console.print(training_table)
-
-    # Memory Estimation
-    memory_table = Table(title="💾 Memory Estimation", title_style="bold yellow")
-    memory_table.add_column("Metric", style="cyan")
-    memory_table.add_column("Value", style="green")
-
-    memory_table.add_row("Estimated GPU Memory", f"{estimated_memory:.1f} GB")
-    if gpu_info["available"]:
-        available_memory = gpu_info["devices"][0]["memory_gb"]
-        memory_table.add_row("Available GPU Memory", f"{available_memory:.1f} GB")
-
-        if estimated_memory > available_memory:
-            status = "[red]⚠️  May exceed available memory[/red]"
-        else:
-            status = "[green]✅ Within memory limits[/green]"
-        memory_table.add_row("Status", status)
-
-    console.print(memory_table)
-    console.print("\n")

hud/cli/rl/gpu.py

@@ -1,63 +0,0 @@
-"""GPU detection and validation utilities for RL training."""
-
-from __future__ import annotations
-
-import subprocess
-from typing import Any
-
-
-def detect_cuda_devices() -> dict[str, Any]:
-    """Detect available CUDA devices and their properties."""
-    try:
-        # Check if CUDA is available
-        result = subprocess.run(
-            ["nvidia-smi", "--query-gpu=index,name,memory.total", "--format=csv,noheader,nounits"],  # noqa: S607
-            capture_output=True,
-            text=True,
-            check=True,
-        )
-
-        if result.returncode != 0:
-            return {"available": False, "error": "nvidia-smi command failed"}
-
-        devices = []
-        for line in result.stdout.strip().split("\n"):
-            parts = line.split(", ")
-            if len(parts) >= 3:
-                devices.append(
-                    {
-                        "index": int(parts[0]),
-                        "name": parts[1],
-                        "memory_gb": float(parts[2]) / 1024,  # Convert MB to GB
-                    }
-                )
-
-        return {"available": True, "devices": devices}
-
-    except FileNotFoundError:
-        return {
-            "available": False,
-            "error": "nvidia-smi not found - CUDA drivers may not be installed",
-        }
-    except Exception as e:
-        return {"available": False, "error": str(e)}
-
-
-def select_gpu_for_vllm(devices: list[dict[str, Any]]) -> int:
-    """Select the best GPU for vLLM server (typically GPU 1 if available)."""
-    if len(devices) > 1:
-        # Prefer GPU 1 for vLLM to leave GPU 0 for other processes
-        return 1
-    return 0
-
-
-def validate_gpu_memory(gpu_memory_gb: float, model_size: str = "3B") -> bool:
-    """Validate if GPU has sufficient memory for the model."""
-    min_memory_requirements = {
-        "3B": 12.0,  # Minimum for Qwen 2.5 VL 3B
-        "7B": 24.0,
-        "14B": 40.0,
-    }
-
-    min_required = min_memory_requirements.get(model_size, 12.0)
-    return gpu_memory_gb >= min_required