Spaces:
Running on Zero
Running on Zero
File size: 4,412 Bytes
e8c5cc2 0dcbcba e8c5cc2 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 | """Configuration loading and global seeding.
Every script in this project takes a YAML config path. Nothing is hardcoded.
"""
from __future__ import annotations
import os
import random
from pathlib import Path
from typing import Any
import numpy as np
import torch
import yaml
from dotenv import load_dotenv
def _load_env_file() -> None:
"""Load .env once, tolerating a malformed one.
Two things go wrong on Windows and both used to be fatal, because this runs
at import time of a module everything else imports:
1. PowerShell's `>` redirection writes UTF-16LE with a BOM. python-dotenv
reads UTF-8 only and raises UnicodeDecodeError, which took down every
entrypoint in the project with a stack trace pointing at dotenv rather
than at the actual problem.
2. Any other parse error did the same.
A broken .env should cost you generation, not the whole application.
"""
try:
load_dotenv(override=False)
return
except UnicodeDecodeError:
pass
except Exception as exc: # noqa: BLE001
print(f"[config] .env could not be parsed ({type(exc).__name__}); ignoring it")
return
# Retry through the encodings Windows editors actually produce.
path = Path(".env")
if not path.exists():
return
raw = path.read_bytes()
for encoding in ("utf-16", "utf-16-le", "utf-16-be", "latin-1"):
try:
text = raw.decode(encoding)
except UnicodeDecodeError:
continue
for line in text.replace("\r\n", "\n").split("\n"):
line = line.strip()
if not line or line.startswith("#") or "=" not in line:
continue
key, _, value = line.partition("=")
os.environ.setdefault(key.strip(), value.strip())
print(
f"[config] .env was {encoding}, not UTF-8 - loaded anyway. "
"Rewrite it as UTF-8 to silence this."
)
return
print("[config] .env is not readable in any known encoding; ignoring it")
_load_env_file()
class Config(dict):
"""A dict that also supports attribute access and dotted lookup."""
def __getattr__(self, name: str) -> Any:
try:
value = self[name]
except KeyError as exc:
raise AttributeError(name) from exc
return Config(value) if isinstance(value, dict) else value
def get_path(self, dotted: str, default: Any = None) -> Any:
"""Look up a nested key such as 'retrieval.dense.model'."""
node: Any = self
for part in dotted.split("."):
if not isinstance(node, dict) or part not in node:
return default
node = node[part]
return node
def load_config(path: str | Path) -> Config:
"""Read a YAML config file into a Config object."""
with open(path, encoding="utf-8") as handle:
raw = yaml.safe_load(handle)
if not isinstance(raw, dict):
raise ValueError(f"Config at {path} must be a YAML mapping")
return Config(raw)
def seed_everything(seed: int) -> int:
"""Seed python, numpy and torch. Returns the seed so callers can log it."""
os.environ["PYTHONHASHSEED"] = str(seed)
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
if torch.cuda.is_available():
torch.cuda.manual_seed_all(seed)
return seed
def device() -> str:
"""Return the torch device string this machine should use.
RESEARCHOS_DEVICE overrides autodetection. Needed on ZeroGPU Spaces, where
torch.cuda.is_available() is patched to return True (CUDA emulation) even
though real CUDA only exists inside @spaces.GPU functions - trusting it
crashes model loading with "Low-level CUDA init reached".
"""
forced = os.environ.get("RESEARCHOS_DEVICE", "").strip().lower()
if forced in ("cpu", "cuda"):
return forced
return "cuda" if torch.cuda.is_available() else "cpu"
def report_vram(tag: str) -> float:
"""Print and return peak allocated VRAM in GB. Required after every GPU run."""
if not torch.cuda.is_available():
print(f"[vram] {tag}: no CUDA device")
return 0.0
peak_gb = torch.cuda.max_memory_allocated() / 1e9
total_gb = torch.cuda.get_device_properties(0).total_memory / 1e9
print(f"[vram] {tag}: peak {peak_gb:.2f} GB / {total_gb:.2f} GB total")
return peak_gb
|