GROMAIVN / trainer_source /grom_runtime.py
GRIMIAI-VNAnhdev's picture
Upload GROM trainer source code
fc1b627 verified
Raw History Blame
17.4 kB
"""Shared runtime contract for GROM Mini.
All Python entrypoints import paths/config from here so the project has one source of truth.
"""
from __future__ import annotations
import json
import os
import platform
import shutil
import subprocess
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parent
CONFIG_PATH = ROOT / "config.json"
_BOOT_CFG = {}
try:
_BOOT_CFG = json.loads(CONFIG_PATH.read_text(encoding="utf-8").replace("\ufeff", ""))
except Exception:
pass
_DATA_ROOT_RAW = os.environ.get("GROM_DATA_ROOT") or _BOOT_CFG.get("dataset_root") or "data/data"
DATA_ROOT = Path(_DATA_ROOT_RAW).expanduser()
if not DATA_ROOT.is_absolute():
DATA_ROOT = ROOT / DATA_ROOT
# Dataset storage is intentionally C:-local only. Any external drive path is rejected.
if DATA_ROOT.drive.upper() != ROOT.drive.upper():
DATA_ROOT = ROOT / "data" / "data"
_OUTPUT_ROOT_RAW = _BOOT_CFG.get("dataset_output_root") or str(ROOT / "data" / "dataset")
DATASET_OUTPUT_ROOT = Path(_OUTPUT_ROOT_RAW).expanduser()
if not DATASET_OUTPUT_ROOT.is_absolute():
DATASET_OUTPUT_ROOT = ROOT / DATASET_OUTPUT_ROOT
if DATASET_OUTPUT_ROOT.drive.upper() != ROOT.drive.upper():
DATASET_OUTPUT_ROOT = ROOT / "data" / "dataset"
SOURCES_DIR = DATA_ROOT / "sources"
RAW_TEXT_DIR = DATA_ROOT / "raw_text"
TRAIN_TXT = DATA_ROOT / "train.txt"
TRAIN_SHARDS_DIR = DATASET_OUTPUT_ROOT / "train_shards"
VAL_SHARDS_DIR = DATASET_OUTPUT_ROOT / "val_shards"
DATASET_MANIFEST = TRAIN_SHARDS_DIR / "manifest.json"
DATASET_REPORT = DATASET_OUTPUT_ROOT / "dataset_report.json"
PICTURE_DIR = ROOT / "data" / "picture"
MODEL_PATH = ROOT / "grom_mini.pt"
CHECKPOINT_PATH = ROOT / "checkpoint.pt"
TOKENIZER_PATH = ROOT / "tokenizer.json"
TOKENIZER_META_PATH = ROOT / "tokenizer.meta.json"
PROGRESS_PATH = ROOT / "parquet_progress.json"
EXCLUDED_DATA_DIRS = {
".git", ".venv", "venv", "__pycache__", "node_modules",
"train_shards", "_needs_review", "_unique_stage", "_dedup",
"checkpoints", "models", "dist", "build", ".cache", "site-packages",
}
def load_config() -> dict:
path = Path(os.environ.get("GROM_CONFIG", str(CONFIG_PATH))).expanduser()
if not path.is_absolute():
path = ROOT / path
if not path.exists():
return {}
return json.loads(path.read_text(encoding="utf-8").replace("", ""))
CFG = load_config()
# Canonical product identity. Keep these values centralized so every
# builder, tokenizer, trainer and inference entrypoint speaks the same name.
AI_NAME = "GynixA.I"
AI_FULL_NAME = "GynixA.I"
DEVELOPER_NAME = "Mixtralrde Cineten Ktinde"
RESPONSE_MARKER = AI_NAME + ":"
def directory_size(path: Path) -> int:
total = 0
if not path.exists():
return 0
for p in path.rglob("*"):
try:
if p.is_file():
total += p.stat().st_size
except OSError:
pass
return total
def available_ram_bytes() -> int:
if os.name == "nt":
try:
import ctypes
class MEMORYSTATUSEX(ctypes.Structure):
_fields_ = [("dwLength", ctypes.c_ulong), ("dwMemoryLoad", ctypes.c_ulong),
("ullTotalPhys", ctypes.c_ulonglong), ("ullAvailPhys", ctypes.c_ulonglong),
("ullTotalPageFile", ctypes.c_ulonglong), ("ullAvailPageFile", ctypes.c_ulonglong),
("ullTotalVirtual", ctypes.c_ulonglong), ("ullAvailVirtual", ctypes.c_ulonglong),
("sullAvailExtendedVirtual", ctypes.c_ulonglong)]
m = MEMORYSTATUSEX()
m.dwLength = ctypes.sizeof(m)
if ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(m)):
return int(m.ullAvailPhys)
except Exception:
pass
try:
import psutil
return int(psutil.virtual_memory().available)
except Exception:
return 0
def system_ram_bytes() -> int:
if os.name == "nt":
try:
import ctypes
class MEMORYSTATUSEX(ctypes.Structure):
_fields_ = [("dwLength", ctypes.c_ulong), ("dwMemoryLoad", ctypes.c_ulong),
("ullTotalPhys", ctypes.c_ulonglong), ("ullAvailPhys", ctypes.c_ulonglong),
("ullTotalPageFile", ctypes.c_ulonglong), ("ullAvailPageFile", ctypes.c_ulonglong),
("ullTotalVirtual", ctypes.c_ulonglong), ("ullAvailVirtual", ctypes.c_ulonglong),
("sullAvailExtendedVirtual", ctypes.c_ulonglong)]
m = MEMORYSTATUSEX()
m.dwLength = ctypes.sizeof(m)
if ctypes.windll.kernel32.GlobalMemoryStatusEx(ctypes.byref(m)):
return int(m.ullTotalPhys)
except Exception:
pass
try:
import psutil
return int(psutil.virtual_memory().total)
except Exception:
return 0
def gpu_memory_mib() -> int:
"""Return total VRAM in MiB on Windows or Linux; 0 means unknown."""
if not shutil.which("nvidia-smi"):
return 0
try:
out = subprocess.check_output(
["nvidia-smi", "--query-gpu=memory.total", "--format=csv,noheader,nounits"],
text=True, stderr=subprocess.DEVNULL, timeout=3,
)
values = [int(x.strip()) for x in out.splitlines() if x.strip().isdigit()]
# Training uses device 0; do not use the largest GPU if multiple GPUs differ.
return values[0] if values else 0
except Exception:
return 0
def has_cuda() -> bool:
"""Return whether the active Python/PyTorch runtime can really execute CUDA."""
if str(CFG.get("force_cpu", "")).lower() in {"1", "true", "yes"}:
return False
try:
import torch
return bool(torch.cuda.is_available())
except Exception:
return False
def gpu_name() -> str:
if not has_cuda():
return ""
try:
import torch
return str(torch.cuda.get_device_name(0))
except Exception:
return ""
def h100_profile() -> bool:
"""True only when the active CUDA device is actually an H100/H200."""
name = gpu_name().lower()
return bool(has_cuda() and ("h100" in name or "h200" in name))
def dataset_roots() -> list[Path]:
"""Raw/extra roots that feed the active dataset builder."""
roots: list[Path] = []
configured = str(CFG.get("dataset_root", "")).strip()
if configured:
p = Path(configured).expanduser()
if not p.is_absolute():
p = ROOT / p
if p.exists() and p.drive.upper() == ROOT.drive.upper():
roots.append(p)
explicit = ROOT / "dataset"
if explicit.exists():
roots.append(explicit)
for raw in CFG.get("dataset_extra_roots", []) or []:
p = Path(str(raw)).expanduser()
if not p.is_absolute():
p = ROOT / p
if p.exists() and p.drive.upper() == ROOT.drive.upper():
roots.append(p)
if not roots:
roots.append(DATA_ROOT)
out = []
seen = set()
for p in roots:
key = str(p.resolve()).lower()
if key not in seen:
seen.add(key); out.append(p)
return out
def low_resource_profile() -> bool:
"""True only when both usable compute memory and host memory are constrained."""
ram = system_ram_bytes()
vram_mib = gpu_memory_mib() if has_cuda() else 0
# A real CUDA GPU with >4 GiB VRAM should not be forced to CPU just because
# the host has little RAM. If VRAM cannot be detected, fall back to RAM.
if has_cuda() and vram_mib > 4096:
return False
ram_low = 0 < ram <= 8 * 1024**3
vram_low = bool(has_cuda() and 0 < vram_mib <= 4096)
return ram_low or vram_low
def gpu_profile() -> str:
"""Choose a conservative training profile from the active GPU's actual VRAM."""
if not has_cuda():
return "cpu"
name = gpu_name().lower()
vram = gpu_memory_mib()
if "h100" in name or "h200" in name:
return "h100"
if vram >= 70000:
return "gpu80"
if vram >= 40000:
return "gpu48"
if vram >= 23000:
return "gpu24"
if vram >= 14000:
return "gpu16"
if vram >= 9000:
return "gpu10"
if vram > 0:
return "gpu_small"
return "gpu_unknown"
def training_config(cfg: dict | None = None) -> dict:
c = dict(CFG if cfg is None else cfg)
profile = gpu_profile()
c["active_gpu_profile"] = profile
vram_mib = gpu_memory_mib() if has_cuda() else 0
if profile == "h100":
c["force_cpu"] = False
c["low_resource_auto"] = False
c["full_corpus_gpu"] = True
c["full_corpus_no_caps"] = True
c["dataset_target_gib"] = 0
c["tokenizer_max_chars"] = 0
c["parquet_max_chars"] = 0
c["image_max_per_run"] = 0
c["image_max_seconds"] = 0
c["image_target_per_class"] = 0
c["training_steps_hard_max"] = 0
c["training_auto_scale"] = True
c["training_epochs"] = max(1.0, float(c.get("training_epochs_h100", 1.0)))
c["block_size"] = max(1024, int(c.get("block_size_h100", 16384)))
c["batch_size"] = max(1, int(c.get("batch_size_h100", 2)))
c["img_batch_size"] = max(1, int(c.get("img_batch_size_h100", 32)))
c["img_every"] = max(1, int(c.get("img_every_h100", 1)))
c["gradient_checkpointing"] = bool(c.get("gradient_checkpointing_h100", True))
return c
if profile in {"gpu80", "gpu48", "gpu24", "gpu16", "gpu10", "gpu_small", "gpu_unknown"}:
# Conservative defaults; actual peak VRAM depends on model, kernels and data.
tiers = {
"gpu80": (8192, 8, 32, 1),
"gpu48": (4096, 4, 16, 1),
"gpu24": (2048, 1, 8, 2),
"gpu16": (1024, 1, 4, 2),
"gpu10": (512, 1, 2, 4),
"gpu_small": (256, 1, 1, 8),
"gpu_unknown":(512, 1, 2, 4),
}
block, batch, img_batch, img_every = tiers[profile]
c["force_cpu"] = False
c["full_corpus_gpu"] = False
c["full_corpus_no_caps"] = False
# Hardware profile owns memory-sensitive values; don't let stale config
# (for example batch=48/block=512 from another machine) override detection.
c["block_size"] = block
c["batch_size"] = batch
c["img_batch_size"] = img_batch
c["img_every"] = img_every
c["gradient_checkpointing"] = True
c["training_auto_scale"] = True
# Do not let an old H100-only setting leak into non-H100 GPU runs.
c["training_steps_hard_max"] = max(1, int(c.get("training_steps_hard_max", 8000) or 8000))
c["vision"] = bool(c.get("vision", True)) and profile not in {"gpu_small"}
return c
# CPU fallback: retain the existing low-resource guardrails.
if not low_resource_profile() or bool(c.get("allow_large_cpu_model", False)):
return c
c["force_cpu"] = True
c["vision"] = False
c["image_auto_download"] = False
c["block_size"] = min(int(c.get("block_size", 192)), 192)
c["batch_size"] = min(int(c.get("batch_size", 8)), 1)
c["n_embd"] = min(int(c.get("n_embd", 192)), 256)
c["n_head"] = min(int(c.get("n_head", 6)), 4)
c["n_layer"] = min(int(c.get("n_layer", 5)), 6)
c["img_batch_size"] = 1
c["img_every"] = 0
c["tokenizer_max_chars"] = min(int(c.get("tokenizer_max_chars", 600_000_000)), 20_000_000)
c["parquet_max_chars"] = min(int(c.get("parquet_max_chars", 20_000_000)), 4_000_000)
c["training_steps_min"] = min(int(c.get("training_steps_min", 14000)), 2000)
c["training_steps_upgrade"] = min(int(c.get("training_steps_upgrade", 50000)), 8000)
c["training_auto_scale"] = True
return c
def validate_config(cfg: dict | None = None) -> list[str]:
c = CFG if cfg is None else cfg
errors = []
vocab = int(c.get("vocab_size", 8000))
block = int(c.get("block_size", 192))
embd = int(c.get("n_embd", 192))
heads = int(c.get("n_head", 6))
layers = int(c.get("n_layer", 5))
if vocab < 256: errors.append("vocab_size must be >= 256")
if block < 32: errors.append("block_size must be >= 32")
if embd < 32: errors.append("n_embd must be >= 32")
if heads < 1 or embd % heads: errors.append("n_embd must be divisible by n_head")
if layers < 1: errors.append("n_layer must be >= 1")
if float(c.get("temperature", 0.45)) <= 0: errors.append("temperature must be > 0")
if not 0 < float(c.get("top_p", 0.9)) <= 1: errors.append("top_p must be in (0,1]")
return errors
def manifest_paths() -> list[Path]:
if not DATASET_MANIFEST.exists():
return []
try:
m = json.loads(DATASET_MANIFEST.read_text(encoding="utf-8"))
return [TRAIN_SHARDS_DIR / str(x) for x in m.get("train_shards", m.get("shards", []))]
except Exception:
return []
def dataset_fingerprint(manifest: dict | None = None) -> str:
import hashlib
m = manifest
if m is None:
if not DATASET_MANIFEST.exists():
return ""
m = json.loads(DATASET_MANIFEST.read_text(encoding="utf-8"))
h = hashlib.sha256()
entries = m.get("source_manifest") or m.get("source_files") or []
for x in entries:
h.update(str(x.get("path")).encode("utf-8"))
h.update(b"\0")
h.update(str(x.get("bytes")).encode("utf-8"))
h.update(b"\0")
h.update(str(x.get("sha256", x.get("mtime_ns", ""))).encode("utf-8"))
h.update(b"\n")
pipeline = str(m.get("pipeline", "grom_record_dedup"))
quality = str(m.get("quality_profile", "response_and_code_v2"))
segmentation = str(m.get("record_segmentation", "role_aware_v2"))
safety = str(m.get("safety_filter", "strict_assistant_safe_v1"))
h.update(f"pipeline={pipeline}\nquality={quality}\nsegmentation={segmentation}\nsafety={safety}\n".encode("utf-8"))
identity_policy = str(m.get("identity_policy", "single_canonical_identity_v2"))
if identity_policy != "single_canonical_identity_v2":
h.update(f"identity={identity_policy}\n".encode("utf-8"))
h.update(f"unique={m.get('unique_records', 0)}\n".encode("utf-8"))
h.update(f"bytes={m.get('unique_bytes', 0)}\n".encode("utf-8"))
h.update(f"duplicates={m.get('duplicate_records', 0)}\n".encode("utf-8"))
h.update(f"rejected={m.get('rejected_records', 0)}".encode("utf-8"))
return h.hexdigest()
def verify_manifest(require_dedup: bool = False, require_validation: bool = False) -> dict:
if not DATASET_MANIFEST.exists():
raise FileNotFoundError(f"Missing dataset manifest: {DATASET_MANIFEST}")
m = json.loads(DATASET_MANIFEST.read_text(encoding="utf-8"))
if require_dedup and m.get("dedup_mode") != "record_sha256":
raise RuntimeError("Dataset manifest is not record-level deduplicated.")
if require_validation and not m.get("val_shards"):
raise RuntimeError("Dataset manifest has no validation split.")
missing = []
actual = 0
for p in manifest_paths():
if not p.exists():
missing.append(p.name)
else:
actual += p.stat().st_size
val_dir = DATASET_OUTPUT_ROOT / "val_shards"
for name in m.get("val_shards", []):
p = val_dir / str(name)
if not p.exists():
missing.append(str(name))
else:
actual += p.stat().st_size
expected = int(m.get("actual_bytes", 0) or 0)
if missing:
raise RuntimeError("Missing shards: " + ", ".join(missing[:20]))
if actual != expected:
raise RuntimeError(f"Manifest byte mismatch: actual={actual} expected={expected}")
return m
def print_runtime_status(cfg: dict | None = None) -> None:
c = training_config(cfg)
ram = system_ram_bytes()
free = available_ram_bytes()
print(f"[runtime] root={ROOT}")
print(f"[runtime] python={sys.executable}")
print(f"[runtime] platform={platform.platform()}")
print(f"[runtime] ram={ram / 1024**3:.2f} GiB available={free / 1024**3:.2f} GiB" if ram else "[runtime] ram=unknown")
vram_mib = gpu_memory_mib() if has_cuda() else 0
print(f"[runtime] gpu={gpu_name() or 'none'} vram={vram_mib / 1024:.1f} GiB profile={gpu_profile()} cuda={has_cuda()} h100_profile={h100_profile()} low_resource={low_resource_profile()}")
print(f"[runtime] raw_dataset={DATA_ROOT} roots={', '.join(str(x) for x in dataset_roots())}")
print(f"[runtime] output_dataset={DATASET_OUTPUT_ROOT}")
print(f"[runtime] shards={TRAIN_SHARDS_DIR}")
print(f"[runtime] effective_model={c.get('n_embd')}d/{c.get('n_head')}h/{c.get('n_layer')}L block={c.get('block_size')} batch={c.get('batch_size')}")
__all__ = [
"ROOT", "CONFIG_PATH", "DATA_ROOT", "DATASET_OUTPUT_ROOT", "SOURCES_DIR", "RAW_TEXT_DIR", "TRAIN_TXT",
"TRAIN_SHARDS_DIR", "VAL_SHARDS_DIR", "DATASET_MANIFEST", "DATASET_REPORT", "PICTURE_DIR",
"MODEL_PATH", "CHECKPOINT_PATH", "TOKENIZER_PATH", "TOKENIZER_META_PATH", "PROGRESS_PATH",
"EXCLUDED_DATA_DIRS", "CFG", "AI_NAME", "AI_FULL_NAME", "DEVELOPER_NAME", "RESPONSE_MARKER", "load_config", "training_config", "validate_config",
"verify_manifest", "manifest_paths", "dataset_fingerprint", "directory_size", "system_ram_bytes",
"available_ram_bytes", "has_cuda", "gpu_name", "gpu_memory_mib", "gpu_profile", "h100_profile", "dataset_roots",
"low_resource_profile", "print_runtime_status",
]