Scriptwriter dataset sync

HOW_TO.txt

@@ -0,0 +1,13 @@
+1. Upload this whole folder to the pod (scp / File Manager) as /workspace/scriptwriter-runpod
+2. On the pod web terminal (one line at a time if needed):
+
+   export HF_TOKEN=hf_YOUR_TOKEN
+   cd /workspace/scriptwriter-runpod
+   bash run.sh
+
+3. Attach later:  tmux attach -t scriptwriter-train
+4. When done: STOP THE POD
+
+Dataset: datamatters24/scriptwriter-corpus-ia
+Model out: datamatters24/scriptwriter-lora-ia
+Accept Llama 3.2 license on Hugging Face before training.

runpod-bootstrap.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+# Run on RunPod (after export HF_TOKEN=...):
+#   curl -fsSL -H "Authorization: Bearer $HF_TOKEN" \
+#     "https://huggingface.co/datasets/datamatters24/scriptwriter-runpod/resolve/main/runpod-bootstrap.sh" \
+#     | bash
+set -euo pipefail
+
+REPO="${RUNPOD_BUNDLE_REPO:-datamatters24/scriptwriter-runpod}"
+BASE="https://huggingface.co/datasets/${REPO}/resolve/main"
+DEST="${WORKDIR:-/workspace/scriptwriter-runpod}"
+TGZ="/tmp/scriptwriter-runpod-ready.tgz"
+
+if [[ -z "${HF_TOKEN:-}" ]]; then
+  echo "Set HF_TOKEN first:  export HF_TOKEN=hf_..."
+  exit 1
+fi
+
+echo "=== Downloading RunPod bundle from ${REPO} ==="
+mkdir -p "$(dirname "$DEST")"
+curl -fsSL -H "Authorization: Bearer ${HF_TOKEN}" \
+  "${BASE}/scriptwriter-runpod-ready.tgz" \
+  -o "${TGZ}"
+
+rm -rf "${DEST}"
+mkdir -p "${DEST}"
+tar xzf "${TGZ}" -C "${DEST}" --strip-components=1
+# tarball contains top-level runpod-ready/ ; strip so DEST has run.sh
+
+if [[ ! -f "${DEST}/run.sh" ]]; then
+  # fallback if strip didn't apply (flat extract)
+  if [[ -f "${DEST}/runpod-ready/run.sh" ]]; then
+    DEST="${DEST}/runpod-ready"
+  else
+    echo "ERROR: run.sh not found after extract"; find "${DEST}" | head -40; exit 1
+  fi
+fi
+
+echo "=== Bundle ready at ${DEST} ==="
+cd "${DEST}"
+export WORKDIR="${DEST}"
+bash "${DEST}/run.sh"

runpod-ready/HOW_TO.txt

@@ -0,0 +1,13 @@
+1. Upload this whole folder to the pod (scp / File Manager) as /workspace/scriptwriter-runpod
+2. On the pod web terminal (one line at a time if needed):
+
+   export HF_TOKEN=hf_YOUR_TOKEN
+   cd /workspace/scriptwriter-runpod
+   bash run.sh
+
+3. Attach later:  tmux attach -t scriptwriter-train
+4. When done: STOP THE POD
+
+Dataset: datamatters24/scriptwriter-corpus-ia
+Model out: datamatters24/scriptwriter-lora-ia
+Accept Llama 3.2 license on Hugging Face before training.

runpod-ready/config/training.yaml

@@ -0,0 +1,82 @@
+# Scriptwriter model training configuration
+
+project:
+  name: scriptwriter-trainer
+  version: "0.1.0"
+
+ollama:
+  host: "${OLLAMA_HOST:-http://127.0.0.1:11434}"
+  model: "${OLLAMA_MODEL:-llama3.2:3b}"
+  timeout_sec: 600
+  num_ctx: 8192
+  keep_alive: "-1"
+
+data:
+  raw_scripts_dir: data/raw/scripts
+  raw_theory_dir: data/raw/theory
+  raw_ia_screenplays_dir: data/raw/archive/screenplay-collection
+  processed_dir: data/processed
+  # Smaller chunks + ctx = faster CPU Ollama (net win vs 16k)
+  chunk_chars: 6000
+  chunk_overlap: 400
+  sources:
+    local_scripts:
+      dir: data/raw/scripts
+      type: script
+      training_round: local
+    local_theory:
+      dir: data/raw/theory
+      type: theory
+      training_round: local
+    ia_screenplays:
+      dir: data/raw/archive/screenplay-collection
+      type: script
+      training_round: ia
+      patterns:
+        - "*_djvu.txt"
+        - "*.txt"
+        - "*.fountain"
+        - "*.pdf"
+
+training_rounds:
+  local:
+    description: Curated PDFs, Fountain scripts, and theory books
+    hf_dataset_repo: "${HF_DATASET_REPO:-}"
+    hf_model_repo: "${HF_MODEL_REPO:-}"
+  ia:
+    description: Internet Archive screenplay-collection (DjVuTXT, ~564 scripts)
+    ia_identifier: screenplay-collection
+    hf_dataset_repo: "${HF_DATASET_REPO_ROUND2:-${HF_DATASET_REPO:-}-ia}"
+    hf_model_repo: "${HF_MODEL_REPO_ROUND2:-${HF_MODEL_REPO:-}-ia}"
+
+dataset:
+  output_file: data/processed/train.jsonl
+  val_split: 0.05
+  max_samples: 0  # 0 = no limit
+  tasks:
+    - scene_analysis
+    - dialogue_polish
+    - structure_lesson
+
+huggingface:
+  dataset_repo: "${HF_DATASET_REPO:-}"
+  model_repo: "${HF_MODEL_REPO:-}"
+
+training:
+  base_model: meta-llama/Llama-3.2-3B-Instruct
+  max_seq_length: 16384
+  lora_r: 16
+  lora_alpha: 32
+  lora_dropout: 0.05
+  learning_rate: 2.0e-4
+  num_train_epochs: 3
+  per_device_train_batch_size: 2
+  gradient_accumulation_steps: 4
+  warmup_ratio: 0.03
+  logging_steps: 10
+  save_steps: 100
+  output_dir: /workspace/models/lora
+
+runpod:
+  sync_dataset: true
+  push_adapter: true

runpod-ready/requirements-runpod.txt

@@ -0,0 +1,12 @@
+torch>=2.4.0
+transformers>=4.44.0
+datasets>=2.19.0
+peft>=0.12.0
+trl>=0.9.0
+accelerate>=0.33.0
+bitsandbytes>=0.43.0
+huggingface_hub>=0.24.0
+pyyaml>=6.0.0
+tqdm>=4.66.0
+sentencepiece>=0.2.0
+protobuf>=4.25.0

runpod-ready/run.sh

@@ -0,0 +1,8 @@
+#!/bin/bash
+# One-shot: from this directory on the RunPod pod
+#   export HF_TOKEN=hf_...
+#   bash run.sh
+set -euo pipefail
+HERE="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+export WORKDIR="${HERE}"
+bash "${HERE}/scripts/runpod_train_tmux.sh"

runpod-ready/scripts/runpod_train_tmux.sh

@@ -0,0 +1,238 @@
+#!/bin/bash
+# =============================================================================
+# RunPod: download scriptwriter dataset from HF → LoRA train in tmux → upload
+# =============================================================================
+# Designed for your 2x A40 pod (~$0.98/hr). Run once on the pod:
+#
+#   export HF_TOKEN=hf_...
+#   bash runpod_train_tmux.sh
+#
+# Optional overrides:
+#   HF_DATASET_REPO   (default: datamatters24/scriptwriter-corpus-ia)
+#   HF_MODEL_REPO     (default: datamatters24/scriptwriter-lora-ia)
+#   BASE_MODEL        (default: meta-llama/Llama-3.2-3B-Instruct)
+#   TMUX_SESSION      (default: scriptwriter-train)
+#   WORKDIR           (default: /workspace/scriptwriter-trainer)
+#
+# Prerequisites on the pod:
+#   - This repo present at WORKDIR (scripts/ + config/ at minimum)
+#   - HF account has accepted the Llama 3.2 license for BASE_MODEL
+#   - nvidia-smi works
+# =============================================================================
+
+set -euo pipefail
+
+TMUX_SESSION="${TMUX_SESSION:-scriptwriter-train}"
+WORKDIR="${WORKDIR:-/workspace/scriptwriter-trainer}"
+HF_DATASET_REPO="${HF_DATASET_REPO:-datamatters24/scriptwriter-corpus-ia}"
+HF_MODEL_REPO="${HF_MODEL_REPO:-datamatters24/scriptwriter-lora-ia}"
+BASE_MODEL="${BASE_MODEL:-meta-llama/Llama-3.2-3B-Instruct}"
+DATA_DIR="${DATA_DIR:-/workspace/data/processed}"
+OUT_DIR="${OUTPUT_DIR:-/workspace/models/lora}"
+LOG_DIR="${LOG_DIR:-/workspace/logs}"
+TIMESTAMP="$(date +%Y%m%d_%H%M%S)"
+TRAIN_LOG="${LOG_DIR}/train_${TIMESTAMP}.log"
+
+# Resolve repo root: prefer script location, then WORKDIR, then /workspace
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+if [[ -f "${SCRIPT_DIR}/train_runpod.py" ]]; then
+  ROOT="$(cd "${SCRIPT_DIR}/.." && pwd)"
+elif [[ -f "${WORKDIR}/scripts/train_runpod.py" ]]; then
+  ROOT="${WORKDIR}"
+elif [[ -f /workspace/scripts/train_runpod.py ]]; then
+  ROOT="/workspace"
+else
+  echo "ERROR: cannot find scripts/train_runpod.py"
+  echo "Copy the scriptwriter-trainer repo to ${WORKDIR} (need scripts/ and config/),"
+  echo "then re-run:  bash ${WORKDIR}/scripts/runpod_train_tmux.sh"
+  exit 1
+fi
+
+cd "${ROOT}"
+mkdir -p "${DATA_DIR}" "${OUT_DIR}" "${LOG_DIR}"
+
+echo "========== Scriptwriter RunPod trainer =========="
+echo "ROOT=${ROOT}"
+echo "HF_DATASET_REPO=${HF_DATASET_REPO}"
+echo "HF_MODEL_REPO=${HF_MODEL_REPO}"
+echo "BASE_MODEL=${BASE_MODEL}"
+echo "DATA_DIR=${DATA_DIR}"
+echo "OUT_DIR=${OUT_DIR}"
+echo "LOG=${TRAIN_LOG}"
+echo
+
+if [[ -z "${HF_TOKEN:-}" ]]; then
+  echo "ERROR: HF_TOKEN is not set."
+  echo "  export HF_TOKEN=hf_xxxxxxxx"
+  exit 1
+fi
+
+if ! command -v nvidia-smi >/dev/null 2>&1; then
+  echo "WARNING: nvidia-smi not found — training will be very slow/CPU."
+else
+  nvidia-smi -L || true
+fi
+
+echo "=== Installing Python deps (if needed) ==="
+python3 -m pip install -q --upgrade pip
+if [[ -f "${ROOT}/requirements-runpod.txt" ]]; then
+  python3 -m pip install -q -r "${ROOT}/requirements-runpod.txt"
+else
+  python3 -m pip install -q \
+    torch transformers datasets peft trl accelerate bitsandbytes \
+    huggingface_hub pyyaml tqdm sentencepiece protobuf
+fi
+python3 -m pip install -q "huggingface_hub>=0.24.0"
+
+export HF_TOKEN
+export HUGGING_FACE_HUB_TOKEN="${HF_TOKEN}"
+export HF_HOME="${HF_HOME:-/workspace/.cache/huggingface}"
+export CONFIG_PATH="${CONFIG_PATH:-${ROOT}/config/training.yaml}"
+export HF_DATASET_REPO HF_MODEL_REPO BASE_MODEL
+export OUTPUT_DIR="${OUT_DIR}"
+# train_runpod.py looks under ROOT/data/processed — symlink pod data there
+mkdir -p "${ROOT}/data"
+if [[ ! -e "${ROOT}/data/processed" ]]; then
+  ln -sfn "${DATA_DIR}" "${ROOT}/data/processed"
+elif [[ ! -L "${ROOT}/data/processed" && "${ROOT}/data/processed" != "${DATA_DIR}" ]]; then
+  # Prefer downloading into DATA_DIR and also ensure ROOT sees train.jsonl
+  mkdir -p "${ROOT}/data/processed"
+fi
+
+echo
+echo "=== Downloading dataset: ${HF_DATASET_REPO} ==="
+python3 - <<PY
+import os
+from pathlib import Path
+from huggingface_hub import snapshot_download, login
+
+login(token=os.environ["HF_TOKEN"], add_to_git_credential=False)
+dest = Path(os.environ.get("DATA_DIR", "/workspace/data/processed"))
+dest.mkdir(parents=True, exist_ok=True)
+snapshot_download(
+    repo_id=os.environ["HF_DATASET_REPO"],
+    repo_type="dataset",
+    local_dir=str(dest),
+    token=os.environ["HF_TOKEN"],
+)
+print(f"Downloaded to {dest}")
+for name in sorted(dest.iterdir()):
+    if name.is_file():
+        print(f"  {name.name:30s} {name.stat().st_size:10d} bytes")
+PY
+
+echo
+echo "=== Ensuring train.jsonl / val.jsonl for train_runpod.py ==="
+python3 - <<PY
+from pathlib import Path
+import shutil
+import os
+
+candidates = [
+    Path(os.environ.get("DATA_DIR", "/workspace/data/processed")),
+    Path("${ROOT}/data/processed"),
+]
+# Deduplicate while preserving order
+seen = set()
+dirs = []
+for d in candidates:
+    key = str(d.resolve()) if d.exists() else str(d)
+    if key in seen:
+        continue
+    seen.add(key)
+    dirs.append(d)
+
+def ensure_split(data_dir: Path) -> None:
+    data_dir.mkdir(parents=True, exist_ok=True)
+    train = data_dir / "train.jsonl"
+    if not train.exists():
+        for alt in ("train-ia.jsonl", "train-local.jsonl", "checkpoint-ia.jsonl"):
+            src = data_dir / alt
+            if src.exists() and src.stat().st_size > 0:
+                shutil.copyfile(src, train)
+                print(f"Created {train} from {alt}")
+                break
+    val = data_dir / "val.jsonl"
+    if not val.exists():
+        for alt in ("val-ia.jsonl", "val-local.jsonl"):
+            src = data_dir / alt
+            if src.exists() and src.stat().st_size > 0:
+                shutil.copyfile(src, val)
+                print(f"Created {val} from {alt}")
+                break
+    if not train.exists():
+        raise SystemExit(f"No train.jsonl (or train-ia/train-local) in {data_dir}")
+    n = sum(1 for line in train.open() if line.strip())
+    print(f"{data_dir}: train.jsonl -> {n} examples")
+
+for d in dirs:
+    ensure_split(d)
+
+# Keep ROOT/data/processed in sync if it is a real directory separate from DATA_DIR
+root_proc = Path("${ROOT}/data/processed")
+data_dir = Path(os.environ.get("DATA_DIR", "/workspace/data/processed"))
+if root_proc.resolve() != data_dir.resolve():
+    for name in ("train.jsonl", "val.jsonl"):
+        src = data_dir / name
+        if src.exists():
+            shutil.copyfile(src, root_proc / name)
+            print(f"Copied {name} -> {root_proc / name}")
+PY
+
+WORKER="${LOG_DIR}/_train_worker_${TIMESTAMP}.sh"
+cat > "${WORKER}" <<EOF
+#!/bin/bash
+set -euo pipefail
+cd "${ROOT}"
+export HF_TOKEN='${HF_TOKEN}'
+export HUGGING_FACE_HUB_TOKEN='${HF_TOKEN}'
+export HF_HOME='${HF_HOME}'
+export CONFIG_PATH='${CONFIG_PATH}'
+export BASE_MODEL='${BASE_MODEL}'
+export OUTPUT_DIR='${OUT_DIR}'
+export HF_DATASET_REPO='${HF_DATASET_REPO}'
+export HF_MODEL_REPO='${HF_MODEL_REPO}'
+
+exec > >(tee -a '${TRAIN_LOG}') 2>&1
+
+echo "========== TRAIN START \$(date -Is) =========="
+nvidia-smi || true
+echo "train lines: \$(wc -l < '${ROOT}/data/processed/train.jsonl')"
+python3 '${ROOT}/scripts/train_runpod.py'
+
+echo
+echo "========== UPLOAD ADAPTER \$(date -Is) =========="
+python3 '${ROOT}/scripts/sync_hf.py' upload-model \\
+  --repo '${HF_MODEL_REPO}' \\
+  --folder '${OUT_DIR}'
+
+echo
+echo "========== DONE \$(date -Is) =========="
+echo "Adapter: https://huggingface.co/${HF_MODEL_REPO}"
+echo "STOP THE POD in the RunPod console to stop billing."
+echo
+read -r -p "Press enter to close tmux pane..." _
+EOF
+chmod +x "${WORKER}"
+
+if tmux has-session -t "${TMUX_SESSION}" 2>/dev/null; then
+  echo "tmux session '${TMUX_SESSION}' already exists."
+  echo "  Attach: tmux attach -t ${TMUX_SESSION}"
+  echo "  Kill:   tmux kill-session -t ${TMUX_SESSION}"
+  exit 1
+fi
+
+tmux new-session -d -s "${TMUX_SESSION}" -n train "bash '${WORKER}'"
+tmux new-window -t "${TMUX_SESSION}" -n monitor
+tmux send-keys -t "${TMUX_SESSION}:monitor" \
+  "watch -n 15 'echo === GPUs ===; nvidia-smi --query-gpu=index,name,memory.used,utilization.gpu --format=csv; echo; echo === log ===; tail -20 ${TRAIN_LOG} 2>/dev/null'" Enter
+tmux select-window -t "${TMUX_SESSION}:train"
+
+echo
+echo "Started training in tmux '${TMUX_SESSION}'"
+echo "  Attach:  tmux attach -t ${TMUX_SESSION}"
+echo "  Detach:  Ctrl-b then d"
+echo "  Log:     ${TRAIN_LOG}"
+echo "  Model →  https://huggingface.co/${HF_MODEL_REPO}"
+echo
+echo "When finished (or if something fails): STOP THE POD."

runpod-ready/scripts/sync_hf.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+"""Sync datasets and model artifacts with Hugging Face Hub."""
+
+from __future__ import annotations
+
+import argparse
+import os
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def require_hf() -> None:
+    try:
+        import huggingface_hub  # noqa: F401
+    except ImportError as exc:
+        raise SystemExit("Install huggingface_hub: pip install huggingface_hub") from exc
+
+
+def hf_token() -> str | None:
+    return os.environ.get("HF_TOKEN") or os.environ.get("HUGGING_FACE_HUB_TOKEN")
+
+
+def upload_dataset(repo_id: str, folder: Path, private: bool) -> None:
+    from huggingface_hub import HfApi
+
+    api = HfApi(token=hf_token())
+    api.create_repo(repo_id=repo_id, repo_type="dataset", exist_ok=True, private=private)
+    api.upload_folder(
+        folder_path=str(folder),
+        repo_id=repo_id,
+        repo_type="dataset",
+        commit_message="Scriptwriter dataset sync",
+    )
+    visibility = "private" if private else "public"
+    print(f"Dataset uploaded ({visibility}): https://huggingface.co/datasets/{repo_id}")
+
+
+def download_dataset(repo_id: str, folder: Path) -> None:
+    from huggingface_hub import snapshot_download
+
+    folder.mkdir(parents=True, exist_ok=True)
+    snapshot_download(
+        repo_id=repo_id,
+        repo_type="dataset",
+        local_dir=str(folder),
+        token=hf_token(),
+    )
+    print(f"Dataset downloaded to {folder}")
+
+
+def upload_model(repo_id: str, folder: Path, private: bool) -> None:
+    from huggingface_hub import HfApi
+
+    api = HfApi(token=hf_token())
+    api.create_repo(repo_id=repo_id, repo_type="model", exist_ok=True, private=private)
+    api.upload_folder(
+        folder_path=str(folder),
+        repo_id=repo_id,
+        repo_type="model",
+        commit_message="Scriptwriter LoRA adapter sync",
+    )
+    visibility = "private" if private else "public"
+    print(f"Model uploaded ({visibility}): https://huggingface.co/models/{repo_id}")
+
+
+def download_model(repo_id: str, folder: Path) -> None:
+    from huggingface_hub import snapshot_download
+
+    folder.mkdir(parents=True, exist_ok=True)
+    snapshot_download(
+        repo_id=repo_id,
+        repo_type="model",
+        local_dir=str(folder),
+        token=hf_token(),
+    )
+    print(f"Model downloaded to {folder}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Sync scriptwriter artifacts with HF Hub")
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    up_ds = sub.add_parser("upload-dataset")
+    up_ds.add_argument("--repo", default=os.environ.get("HF_DATASET_REPO", ""))
+    up_ds.add_argument("--folder", type=Path, default=ROOT / "data" / "processed")
+    up_ds.add_argument("--public", action="store_true", help="Upload as public (default: private)")
+
+    down_ds = sub.add_parser("download-dataset")
+    down_ds.add_argument("--repo", default=os.environ.get("HF_DATASET_REPO", ""))
+    down_ds.add_argument("--folder", type=Path, default=ROOT / "data" / "processed")
+
+    up_m = sub.add_parser("upload-model")
+    up_m.add_argument("--repo", default=os.environ.get("HF_MODEL_REPO", ""))
+    up_m.add_argument("--folder", type=Path, default=ROOT / "models" / "lora")
+    up_m.add_argument("--public", action="store_true", help="Upload as public (default: private)")
+
+    down_m = sub.add_parser("download-model")
+    down_m.add_argument("--repo", default=os.environ.get("HF_MODEL_REPO", ""))
+    down_m.add_argument("--folder", type=Path, default=ROOT / "models" / "lora")
+
+    args = parser.parse_args()
+    require_hf()
+
+    if args.cmd == "upload-dataset":
+        if not args.repo:
+            raise SystemExit("Set --repo or HF_DATASET_REPO")
+        upload_dataset(args.repo, args.folder, private=not args.public)
+    elif args.cmd == "download-dataset":
+        if not args.repo:
+            raise SystemExit("Set --repo or HF_DATASET_REPO")
+        download_dataset(args.repo, args.folder)
+    elif args.cmd == "upload-model":
+        if not args.repo:
+            raise SystemExit("Set --repo or HF_MODEL_REPO")
+        upload_model(args.repo, args.folder, private=not args.public)
+    elif args.cmd == "download-model":
+        if not args.repo:
+            raise SystemExit("Set --repo or HF_MODEL_REPO")
+        download_model(args.repo, args.folder)
+
+
+if __name__ == "__main__":
+    main()

runpod-ready/scripts/train_runpod.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""LoRA fine-tuning entrypoint for RunPod GPU pods."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+DEFAULT_CONFIG = ROOT / "config" / "training.yaml"
+
+
+def load_config(path: Path) -> dict:
+    import yaml
+
+    text = path.read_text()
+
+    def repl(match: re.Match[str]) -> str:
+        var, default = match.group(1), match.group(2) or ""
+        return os.environ.get(var, default)
+
+    text = re.sub(r"\$\{([^}:]+)(?::-([^}]*))?\}", repl, text)
+    return yaml.safe_load(text)
+
+
+def format_example(row: dict) -> dict:
+    messages = row["messages"]
+    return {"messages": messages}
+
+
+def main() -> None:
+    import torch
+    from datasets import Dataset, load_dataset
+    from peft import LoraConfig, get_peft_model
+    from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
+    from trl import SFTTrainer
+
+    config_path = Path(os.environ.get("CONFIG_PATH", DEFAULT_CONFIG))
+    cfg = load_config(config_path)
+    train_cfg = cfg["training"]
+
+    data_dir = ROOT / "data" / "processed"
+    train_file = data_dir / "train.jsonl"
+    if not train_file.exists():
+        fallback = ROOT / cfg["dataset"]["output_file"]
+        if fallback.exists():
+            train_file = fallback
+        else:
+            raise SystemExit(f"No training data at {data_dir}/train.jsonl or {fallback}")
+
+    rows = [json.loads(line) for line in train_file.read_text().splitlines() if line.strip()]
+    dataset = Dataset.from_list([format_example(r) for r in rows])
+
+    val_file = data_dir / "val.jsonl"
+    eval_dataset = None
+    if val_file.exists():
+        val_rows = [json.loads(line) for line in val_file.read_text().splitlines() if line.strip()]
+        eval_dataset = Dataset.from_list([format_example(r) for r in val_rows])
+
+    base_model = os.environ.get("BASE_MODEL", train_cfg["base_model"])
+    output_dir = os.environ.get("OUTPUT_DIR", train_cfg["output_dir"])
+    Path(output_dir).mkdir(parents=True, exist_ok=True)
+
+    tokenizer = AutoTokenizer.from_pretrained(base_model, trust_remote_code=True)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    model = AutoModelForCausalLM.from_pretrained(
+        base_model,
+        torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
+        device_map="auto",
+        trust_remote_code=True,
+    )
+
+    lora_config = LoraConfig(
+        r=int(train_cfg["lora_r"]),
+        lora_alpha=int(train_cfg["lora_alpha"]),
+        lora_dropout=float(train_cfg["lora_dropout"]),
+        bias="none",
+        task_type="CAUSAL_LM",
+        target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
+    )
+    model = get_peft_model(model, lora_config)
+
+    def formatting_func(batch):
+        texts = []
+        for messages in batch["messages"]:
+            texts.append(
+                tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=False)
+            )
+        return {"text": texts}
+
+    formatted = dataset.map(formatting_func, batched=True, remove_columns=dataset.column_names)
+    formatted_eval = None
+    if eval_dataset is not None:
+        formatted_eval = eval_dataset.map(
+            formatting_func, batched=True, remove_columns=eval_dataset.column_names
+        )
+
+    max_steps = int(os.environ.get("RUNPOD_MAX_STEPS", "0"))
+    training_args = TrainingArguments(
+        output_dir=output_dir,
+        num_train_epochs=float(train_cfg["num_train_epochs"]) if not max_steps else 1.0,
+        max_steps=max_steps if max_steps > 0 else -1,
+        per_device_train_batch_size=int(train_cfg["per_device_train_batch_size"]),
+        gradient_accumulation_steps=int(train_cfg["gradient_accumulation_steps"]),
+        learning_rate=float(train_cfg["learning_rate"]),
+        warmup_ratio=float(train_cfg["warmup_ratio"]),
+        logging_steps=int(train_cfg["logging_steps"]),
+        save_steps=int(train_cfg["save_steps"]),
+        save_total_limit=2,
+        bf16=torch.cuda.is_available(),
+        report_to="none",
+        remove_unused_columns=False,
+    )
+
+    trainer = SFTTrainer(
+        model=model,
+        args=training_args,
+        train_dataset=formatted,
+        eval_dataset=formatted_eval,
+        processing_class=tokenizer,
+    )
+    trainer.train()
+    trainer.save_model(output_dir)
+    tokenizer.save_pretrained(output_dir)
+
+    meta = {
+        "base_model": base_model,
+        "train_examples": len(rows),
+        "output_dir": output_dir,
+    }
+    Path(output_dir, "training_meta.json").write_text(json.dumps(meta, indent=2))
+    print(json.dumps(meta, indent=2))
+
+
+if __name__ == "__main__":
+    main()

scriptwriter-runpod-ready.tgz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:23780bf461c3358253e87f86d23be19bce240f3ca6d1d284335768879ba1047d
+size 6751