scripts/train_openenv.py

#!/usr/bin/env python3
"""ShopRLVE-GYM OpenEnv RL Training Script.

Trains a language model to act as an e-commerce shopping assistant using
Reinforcement Learning (GRPO) with ShopRLVE-GYM environments as the
reward signal.  Follows the Unsloth + TRL GRPOTrainer pattern from the
OpenEnv 2048 notebook, adapted for multi-turn e-commerce conversation.

Usage:
    # Basic run with defaults (Qwen3-1.7B, C1, 300 steps)
    python scripts/train_openenv.py

    # Full options
    python scripts/train_openenv.py \
        --model Qwen/Qwen3-1.7B \
        --collection C1 \
        --max_steps 300 \
        --lora_rank 16 \
        --num_generations 4 \
        --load_in_4bit \
        --output_dir outputs/shoprlve_grpo

Requires: pip install unsloth trl transformers datasets torch
"""

from __future__ import annotations

import argparse
import json
import logging
import os
import sys
import time
from pathlib import Path
from typing import Any

import numpy as np
import torch

# ---------------------------------------------------------------------------
# Ensure shop_rlve is importable (add src/ to path if needed)
# ---------------------------------------------------------------------------
_SCRIPT_DIR = Path(__file__).resolve().parent
_PROJECT_ROOT = _SCRIPT_DIR.parent
_SRC_DIR = _PROJECT_ROOT / "src"
if str(_SRC_DIR) not in sys.path:
    sys.path.insert(0, str(_SRC_DIR))

from shop_rlve.server.openenv import ShopRLVEEnv
from shop_rlve.server.state import parse_action
from shop_rlve.training.collections import COLLECTIONS, get_collection

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",
)
logger = logging.getLogger("shoprlve.train_openenv")


# ===================================================================
# System prompt (what the model is told about its role & tools)
# ===================================================================

SYSTEM_PROMPT = """\
You are a helpful e-commerce shopping assistant. Your goal is to help \
customers find products, manage orders, handle returns, and answer \
policy questions.

You can use the following tools:
- catalog.search(query, filters, top_k): Search the product catalog
- catalog.rerank(query, candidate_product_ids, top_k): Re-rank products
- catalog.get_product(product_id): Get full product details
- catalog.get_variants(product_id): Get product variants
- cart.add(product_id, variant_id, qty): Add item to cart
- cart.remove(line_id): Remove item from cart
- cart.view(): View current cart
- order.list(days): List recent orders
- order.get_status(order_id): Get order status
- order.checkout(shipping_address_id, payment_method_id): Checkout
- return.initiate(order_id, line_id, reason): Initiate a return
- policy.search(query, top_k): Search policy knowledge base

Respond with valid JSON containing:
{
    "assistant_message": "your message to the user",
    "tool_calls": [{"name": "tool_name", "args": {...}}],
    "answer": {"env": "PD", "recommended_product_ids": [...], "done": true}
}

When you have found the answer, set "done": true in the answer field.\
"""


# ===================================================================
# Environment wrapper — one persistent ShopRLVEEnv instance
# ===================================================================

class ShopRLVEOpenEnv:
    """Thin wrapper around ShopRLVEEnv that stores state for reward
    computation across the GRPO generate → reward pipeline.

    GRPOTrainer generates completions first, then calls reward functions.
    We must be able to reconstruct an episode for each (prompt, completion)
    pair.  Since each prompt is generated from a fresh env.reset(), we
    cache the Observation so the reward function can evaluate it.
    """

    def __init__(self, collection: str = "C1", seed: int = 42) -> None:
        self.env = ShopRLVEEnv(collection=collection, seed=seed)
        self.env.dump_dir = ""       # Disable disk trace during training
        self.env.trace_episodes = False
        self.env.validate_rewards = True
        self.collection = collection
        self.env_ids = get_collection(collection)
        self._episode_counter = 0

    def sample_prompt(self, tokenizer: Any) -> tuple[list[dict[str, str]], str, int]:
        """Reset the env and produce a chat-messages prompt.

        Returns:
            Tuple of (messages, env_id, episode_seed) where messages is
            a list of {"role": ..., "content": ...} dicts suitable for
            tokenizer.apply_chat_template(), and env_id + episode_seed
            can be used to deterministically re-create the exact same
            episode for reward evaluation.
        """
        # Cycle through envs uniformly
        env_id = self.env_ids[self._episode_counter % len(self.env_ids)]
        self._episode_counter += 1

        # Use a deterministic seed so the reward function can
        # reconstruct the exact same episode (same target products,
        # constraints, user message, etc.)
        episode_seed = self._episode_counter * 1000 + 42

        obs = self.env.reset(env_id=env_id, seed=episode_seed)

        # Build messages: [system, user]
        messages: list[dict[str, str]] = [
            {"role": "system", "content": SYSTEM_PROMPT},
        ]
        for msg in obs.conversation:
            messages.append({"role": msg["role"], "content": msg["content"]})

        return messages, env_id, episode_seed

    def evaluate_completion(
        self,
        completion: str,
        env_id: str,
        episode_seed: int,
    ) -> dict[str, Any]:
        """Run one episode: reset with the SAME env_id and seed that
        generated the prompt, then step with the completion.

        Because env.reset() is deterministic for a given (env_id, seed),
        this re-creates the exact same problem instance (same hidden
        goal, constraints, target products, user message, persona) that
        the model saw during generation.

        Args:
            completion:    The model's raw JSON action string.
            env_id:        Environment ID used when the prompt was created.
            episode_seed:  Seed used when the prompt was created.

        Returns:
            Dict with reward, is_correct, turn, termination_reason,
            and reward_breakdown.
        """
        # Re-create the exact same episode the model was prompted with
        obs = self.env.reset(env_id=env_id, seed=episode_seed)

        # Step with the model completion
        obs, reward, done, info = self.env.step(completion)

        # If the model didn't signal done, force a terminal answer
        if not done:
            action, valid = parse_action(completion)
            fallback_env = obs.env_id or env_id
            fallback_answer: dict[str, Any] = {"env": fallback_env, "done": True}
            if action and action.answer:
                fallback_answer = action.answer.model_dump()
                fallback_answer["done"] = True
            else:
                fallback_answer["recommended_product_ids"] = []

            done_action = json.dumps({
                "assistant_message": "Here is my final answer.",
                "tool_calls": [],
                "answer": fallback_answer,
            })
            obs, reward, done, info = self.env.step(done_action)

        return {
            "reward": reward,
            "is_correct": info.get("is_correct", False),
            "turn": info.get("turn", 0),
            "termination_reason": info.get("termination_reason", "unknown"),
            "reward_breakdown": info.get("reward_breakdown", {}),
        }


# ===================================================================
# Reward functions for GRPOTrainer
# ===================================================================

# Global env wrapper -- initialized in main()
_OPENENV: ShopRLVEOpenEnv | None = None
_PRINT_COUNTER: int = 0


def _extract_json_from_completion(text: str) -> str | None:
    """Extract the first JSON object from a completion string.

    Handles cases where the model wraps JSON in markdown code blocks
    or emits thinking tokens before the JSON.
    """
    # Try direct JSON parse first
    text = text.strip()

    # Strip markdown code fences if present
    if "```" in text:
        first = text.find("```") + 3
        second = text.find("```", first)
        if second > first:
            candidate = text[first:second].strip()
            candidate = candidate.removeprefix("json\n").removeprefix("json").strip()
            text = candidate

    # Find the first '{' and last '}'
    start = text.find("{")
    if start == -1:
        return None
    end = text.rfind("}")
    if end == -1 or end < start:
        return None

    candidate = text[start : end + 1]
    try:
        json.loads(candidate)
        return candidate
    except json.JSONDecodeError:
        return None


def format_reward(completions: list[list[dict[str, str]]], **kwargs: Any) -> list[float]:
    """Reward: does the completion parse as valid ShopRLVE action JSON?

    Checks that the output contains a valid JSON object with the
    required 'assistant_message' field.

    +1.0  valid JSON with assistant_message
    -0.5  valid JSON but missing required fields
    -2.0  invalid JSON / no JSON found
    """
    scores: list[float] = []
    for completion in completions:
        response = completion[0]["content"]
        extracted = _extract_json_from_completion(response)

        if extracted is None:
            scores.append(-2.0)
            continue

        action, valid = parse_action(extracted)
        if valid and action is not None:
            scores.append(1.0)
        else:
            scores.append(-0.5)

    return scores


def tool_usage_reward(completions: list[list[dict[str, str]]], **kwargs: Any) -> list[float]:
    """Reward: does the completion use tools appropriately?

    +1.0  has well-formed tool_calls with valid tool names
    +0.5  has answer with done=true but no tool calls (acceptable for
          simple tasks)
    -0.5  has tool_calls but with invalid tool names
    -1.0  no JSON / unparseable
    """
    VALID_TOOL_PREFIXES = {"catalog.", "cart.", "order.", "return.", "policy."}

    scores: list[float] = []
    for completion in completions:
        response = completion[0]["content"]
        extracted = _extract_json_from_completion(response)

        if extracted is None:
            scores.append(-1.0)
            continue

        action, valid = parse_action(extracted)
        if not valid or action is None:
            scores.append(-1.0)
            continue

        if action.tool_calls:
            all_valid = all(
                any(tc.name.startswith(prefix) for prefix in VALID_TOOL_PREFIXES)
                for tc in action.tool_calls
            )
            scores.append(1.0 if all_valid else -0.5)
        elif action.answer and action.answer.done:
            scores.append(0.5)
        else:
            # No tools and no done answer — unhelpful
            scores.append(-0.25)

    return scores


def env_reward(completions: list[list[dict[str, str]]], **kwargs: Any) -> list[float]:
    """Reward: run the completion through the ShopRLVE-GYM environment
    and return the environment's scalar reward.

    This is the core reward that evaluates actual e-commerce task
    performance: product recommendation quality, cart correctness,
    return handling, etc.

    TRL GRPOTrainer passes extra dataset columns through **kwargs,
    so we receive `env_id` and `episode_seed` lists that let us
    reconstruct the exact same episode the prompt came from.

    Reward range: [-1.0, 1.0] from the environment, scaled by 5.0
    to make it the dominant signal.
    """
    global _OPENENV, _PRINT_COUNTER
    assert _OPENENV is not None, "ShopRLVEOpenEnv not initialized"

    # Extract episode identifiers from kwargs (set in the dataset)
    env_ids = kwargs.get("env_id", [])
    episode_seeds = kwargs.get("episode_seed", [])

    scores: list[float] = []
    for i, completion in enumerate(completions):
        response = completion[0]["content"]
        extracted = _extract_json_from_completion(response)

        should_print = (_PRINT_COUNTER % 10 == 0)
        _PRINT_COUNTER += 1

        if extracted is None:
            if should_print:
                logger.info("[env_reward] No JSON found in completion")
            scores.append(-1.0)
            continue

        # Recover the env_id and seed for this sample
        eid = env_ids[i] if i < len(env_ids) else _OPENENV.env_ids[0]
        eseed = episode_seeds[i] if i < len(episode_seeds) else 42

        try:
            result = _OPENENV.evaluate_completion(
                completion=extracted,
                env_id=eid,
                episode_seed=int(eseed),
            )
            env_score = result["reward"]

            if should_print:
                logger.info(
                    "[env_reward] env=%s seed=%d reward=%.4f correct=%s reason=%s breakdown=%s",
                    eid,
                    eseed,
                    env_score,
                    result["is_correct"],
                    result["termination_reason"],
                    {k: f"{v:.3f}" if isinstance(v, float) else v
                     for k, v in result.get("reward_breakdown", {}).items()
                     if k in ("r_task", "r_eff", "r_hall", "r_total")},
                )

            # Scale the env reward to dominate the combined signal
            scores.append(float(env_score) * 5.0)

        except Exception as exc:
            logger.warning("[env_reward] Exception: %s: %s", type(exc).__name__, exc)
            scores.append(-3.0)

    return scores


# ===================================================================
# Dataset builder
# ===================================================================

def build_dataset(
    openenv: ShopRLVEOpenEnv,
    tokenizer: Any,
    n_prompts: int = 1000,
) -> "Dataset":
    """Build a HuggingFace Dataset of prompts sampled from ShopRLVE-GYM.

    Each row has:
        - 'prompt':        list of chat messages for apply_chat_template()
        - 'env_id':        environment ID (e.g. "PD", "SUB", ...)
        - 'episode_seed':  deterministic seed for env.reset()

    TRL GRPOTrainer passes extra columns through to reward functions
    as **kwargs, allowing the reward function to reconstruct the exact
    same episode that generated each prompt.
    """
    from datasets import Dataset

    rows: list[dict[str, Any]] = []
    for i in range(n_prompts):
        messages, env_id, episode_seed = openenv.sample_prompt(tokenizer)
        rows.append({
            "prompt": messages,
            "env_id": env_id,
            "episode_seed": episode_seed,
        })

    dataset = Dataset.from_list(rows)
    logger.info(
        "Built dataset with %d prompts (envs: %s)",
        len(dataset),
        ", ".join(sorted(set(r["env_id"] for r in rows))),
    )
    return dataset


# ===================================================================
# Main training loop
# ===================================================================

def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="ShopRLVE-GYM OpenEnv RL Training with GRPO",
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    # Model
    parser.add_argument(
        "--model", type=str, default="Qwen/Qwen3-1.7B",
        help="HuggingFace model name or path (default: Qwen/Qwen3-1.7B)",
    )
    parser.add_argument(
        "--load_in_4bit", action="store_true", default=True,
        help="Load model in 4-bit quantization (default: True)",
    )
    parser.add_argument(
        "--load_in_16bit", action="store_true", default=False,
        help="Load model in 16-bit (overrides --load_in_4bit)",
    )
    parser.add_argument(
        "--max_seq_length", type=int, default=2048,
        help="Maximum sequence length (default: 2048)",
    )
    parser.add_argument(
        "--lora_rank", type=int, default=16,
        help="LoRA rank (default: 16)",
    )

    # Environment
    parser.add_argument(
        "--collection", type=str, default="C1",
        choices=sorted(COLLECTIONS.keys()),
        help="Environment collection (default: C1)",
    )
    parser.add_argument(
        "--seed", type=int, default=42,
        help="Random seed (default: 42)",
    )
    parser.add_argument(
        "--n_prompts", type=int, default=1000,
        help="Number of training prompts to generate (default: 1000)",
    )

    # Training
    parser.add_argument(
        "--max_steps", type=int, default=300,
        help="Maximum training steps (default: 300)",
    )
    parser.add_argument(
        "--num_generations", type=int, default=4,
        help="GRPO group size G (default: 4)",
    )
    parser.add_argument(
        "--batch_size", type=int, default=1,
        help="Per-device train batch size (default: 1)",
    )
    parser.add_argument(
        "--gradient_accumulation_steps", type=int, default=1,
        help="Gradient accumulation steps (default: 1)",
    )
    parser.add_argument(
        "--learning_rate", type=float, default=2e-5,
        help="Learning rate (default: 2e-5)",
    )
    parser.add_argument(
        "--temperature", type=float, default=0.7,
        help="Sampling temperature (default: 0.7)",
    )
    parser.add_argument(
        "--max_prompt_length", type=int, default=None,
        help="Max prompt length in tokens (auto-detected if None)",
    )
    parser.add_argument(
        "--max_completion_length", type=int, default=512,
        help="Max completion length in tokens (default: 512)",
    )

    # Output
    parser.add_argument(
        "--output_dir", type=str, default="outputs/shoprlve_grpo",
        help="Checkpoint output directory (default: outputs/shoprlve_grpo)",
    )
    parser.add_argument(
        "--save_steps", type=int, default=50,
        help="Save checkpoint every N steps (default: 50)",
    )
    parser.add_argument(
        "--report_to", type=str, default="none",
        choices=["none", "wandb", "tensorboard", "trackio"],
        help="Experiment tracker (default: none)",
    )

    return parser.parse_args()


def main() -> None:
    args = parse_args()

    logger.info("=" * 70)
    logger.info("ShopRLVE-GYM OpenEnv Training")
    logger.info("=" * 70)
    logger.info("Model:      %s", args.model)
    logger.info("Collection: %s -> %s", args.collection, get_collection(args.collection))
    logger.info("LoRA rank:  %d", args.lora_rank)
    logger.info("Max steps:  %d", args.max_steps)
    logger.info("Group size: %d (G)", args.num_generations)
    logger.info("LR:         %s", args.learning_rate)
    logger.info("Output:     %s", args.output_dir)
    logger.info("=" * 70)

    # ------------------------------------------------------------------
    # 1. Initialize ShopRLVE-GYM environment
    # ------------------------------------------------------------------
    logger.info("Initializing ShopRLVE-GYM environment (collection=%s)...", args.collection)
    global _OPENENV
    _OPENENV = ShopRLVEOpenEnv(collection=args.collection, seed=args.seed)
    logger.info(
        "Environment ready: %d envs, catalog loaded",
        len(_OPENENV.env_ids),
    )

    # ------------------------------------------------------------------
    # 2. Load model with Unsloth
    # ------------------------------------------------------------------
    logger.info("Loading model: %s ...", args.model)

    from unsloth import FastLanguageModel

    load_in_4bit = args.load_in_4bit and not args.load_in_16bit

    model, tokenizer = FastLanguageModel.from_pretrained(
        model_name=args.model,
        max_seq_length=args.max_seq_length,
        load_in_4bit=load_in_4bit,
        fast_inference=True,       # Enable vLLM fast inference for GRPO
        max_lora_rank=args.lora_rank,
        gpu_memory_utilization=0.6,  # Reduce if OOM
    )

    logger.info("Model loaded. Adding LoRA adapters (rank=%d)...", args.lora_rank)

    model = FastLanguageModel.get_peft_model(
        model,
        r=args.lora_rank,
        target_modules=[
            "q_proj", "k_proj", "v_proj", "o_proj",
            "gate_proj", "up_proj", "down_proj",
        ],
        lora_alpha=args.lora_rank * 2,
        use_gradient_checkpointing="unsloth",
        random_state=args.seed,
    )

    # ------------------------------------------------------------------
    # 3. Build the training dataset
    # ------------------------------------------------------------------
    logger.info("Building training dataset (%d prompts)...", args.n_prompts)
    dataset = build_dataset(_OPENENV, tokenizer, n_prompts=args.n_prompts)

    # Compute max_prompt_length from a sample if not specified
    if args.max_prompt_length is None:
        sample_text = tokenizer.apply_chat_template(
            dataset[0]["prompt"],
            tokenize=False,
            add_generation_prompt=True,
        )
        sample_len = len(tokenizer.encode(sample_text))
        # Add 20% headroom
        args.max_prompt_length = int(sample_len * 1.2) + 1
        logger.info(
            "Auto-detected max_prompt_length=%d (sample=%d tokens)",
            args.max_prompt_length, sample_len,
        )

    max_completion_length = min(
        args.max_completion_length,
        args.max_seq_length - args.max_prompt_length,
    )
    if max_completion_length <= 0:
        logger.error(
            "max_seq_length (%d) is too small for max_prompt_length (%d). "
            "Increase --max_seq_length or decrease --max_prompt_length.",
            args.max_seq_length, args.max_prompt_length,
        )
        sys.exit(1)

    logger.info(
        "Sequence budget: prompt=%d + completion=%d = %d / %d",
        args.max_prompt_length,
        max_completion_length,
        args.max_prompt_length + max_completion_length,
        args.max_seq_length,
    )

    # ------------------------------------------------------------------
    # 4. Configure GRPO training
    # ------------------------------------------------------------------
    logger.info("Configuring GRPOTrainer...")

    from trl import GRPOConfig, GRPOTrainer

    training_args = GRPOConfig(
        # Generation
        temperature=args.temperature,
        max_prompt_length=args.max_prompt_length,
        max_completion_length=max_completion_length,
        num_generations=args.num_generations,

        # Optimization
        learning_rate=args.learning_rate,
        weight_decay=0.01,
        warmup_ratio=0.1,
        lr_scheduler_type="cosine",
        optim="adamw_8bit",

        # Batching
        per_device_train_batch_size=args.batch_size,
        gradient_accumulation_steps=args.gradient_accumulation_steps,

        # Schedule
        max_steps=args.max_steps,
        logging_steps=1,
        save_steps=args.save_steps,

        # Output
        output_dir=args.output_dir,
        report_to=args.report_to,

        # Misc
        seed=args.seed,
        bf16=torch.cuda.is_bf16_supported(),
        fp16=not torch.cuda.is_bf16_supported(),
    )

    # ------------------------------------------------------------------
    # 5. Create trainer with ShopRLVE reward functions
    # ------------------------------------------------------------------
    logger.info("Creating GRPOTrainer with 3 reward functions...")
    logger.info("  1. format_reward:     valid JSON action format check")
    logger.info("  2. tool_usage_reward: correct tool names & structure")
    logger.info("  3. env_reward:        ShopRLVE-GYM environment reward (×5)")

    trainer = GRPOTrainer(
        model=model,
        processing_class=tokenizer,
        reward_funcs=[
            format_reward,
            tool_usage_reward,
            env_reward,
        ],
        args=training_args,
        train_dataset=dataset,
    )

    # ------------------------------------------------------------------
    # 6. Train!
    # ------------------------------------------------------------------
    logger.info("Starting GRPO training...")
    logger.info(
        "Expect slow initial progress — the model needs ~50-100 steps "
        "to learn JSON formatting before env rewards improve."
    )
    t0 = time.monotonic()

    trainer.train()

    elapsed = time.monotonic() - t0
    logger.info("Training completed in %.1f minutes (%d steps)", elapsed / 60, args.max_steps)

    # ------------------------------------------------------------------
    # 7. Save final model
    # ------------------------------------------------------------------
    final_dir = os.path.join(args.output_dir, "final")
    logger.info("Saving final LoRA adapters to %s ...", final_dir)
    model.save_pretrained(final_dir)
    tokenizer.save_pretrained(final_dir)

    # ------------------------------------------------------------------
    # 8. Quick inference test
    # ------------------------------------------------------------------
    logger.info("Running quick inference test...")
    test_messages, _, _ = _OPENENV.sample_prompt(tokenizer)
    text = tokenizer.apply_chat_template(
        test_messages,
        tokenize=False,
        add_generation_prompt=True,
    )

    # Switch from training mode to inference mode
    FastLanguageModel.for_inference(model)

    from transformers import TextStreamer
    _ = model.generate(
        **tokenizer(text, return_tensors="pt").to("cuda"),
        temperature=0.7,
        max_new_tokens=max_completion_length,
        streamer=TextStreamer(tokenizer, skip_prompt=True),
    )

    logger.info("=" * 70)
    logger.info("Training complete! Model saved to: %s", final_dir)
    logger.info("=" * 70)


if __name__ == "__main__":
    main()