Spaces:
Sleeping
Sleeping
File size: 4,702 Bytes
b2300e2 | 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 133 134 135 136 137 138 139 140 141 142 143 144 | from __future__ import annotations
import os
from dataclasses import dataclass
from pathlib import Path
def _bool_env(name: str, default: bool) -> bool:
value = os.getenv(name)
if value is None:
return default
return value.strip().lower() in {"1", "true", "yes", "on"}
def _float_env(name: str, default: float) -> float:
value = os.getenv(name)
return default if value is None else float(value)
def _int_env(name: str, default: int) -> int:
value = os.getenv(name)
return default if value is None else int(value)
@dataclass(frozen=True)
class Settings:
data_dir: Path
database_path: Path
asr_model: str
asr_timestamps: str
embedding_model: str
visual_model: str
device: str
torch_dtype: str
chunk_length_seconds: float
chunk_overlap_seconds: float
frame_sample_interval_seconds: float
max_audio_seconds: float | None
visual_search_enabled: bool
keyword_boost: float
semantic_weight: float
keyword_weight: float
min_speech_score: float
min_visual_score: float
@classmethod
def from_env(cls) -> "Settings":
data_dir = Path(os.getenv("IRIS_DATA_DIR", ".iris-data")).resolve()
return cls(
data_dir=data_dir,
database_path=Path(os.getenv("IRIS_DATABASE_PATH", data_dir / "iris.sqlite3")).resolve(),
asr_model=os.getenv("IRIS_ASR_MODEL", "openai/whisper-large-v3-turbo"),
asr_timestamps=os.getenv("IRIS_ASR_TIMESTAMPS", "word"),
embedding_model=os.getenv("IRIS_EMBEDDING_MODEL", "sentence-transformers/all-MiniLM-L6-v2"),
visual_model=os.getenv("IRIS_VISUAL_MODEL", "openai/clip-vit-large-patch14"),
device=os.getenv("IRIS_DEVICE", "auto"),
torch_dtype=os.getenv("IRIS_TORCH_DTYPE", "auto"),
chunk_length_seconds=_float_env("IRIS_CHUNK_LENGTH_SECONDS", 24.0),
chunk_overlap_seconds=_float_env("IRIS_CHUNK_OVERLAP_SECONDS", 4.0),
frame_sample_interval_seconds=_float_env("IRIS_FRAME_SAMPLE_INTERVAL_SECONDS", 2.0),
max_audio_seconds=_optional_float_env("IRIS_MAX_AUDIO_SECONDS"),
visual_search_enabled=_bool_env("IRIS_VISUAL_SEARCH_ENABLED", True),
keyword_boost=_float_env("IRIS_KEYWORD_BOOST", 0.15),
semantic_weight=_float_env("IRIS_SEMANTIC_WEIGHT", 0.78),
keyword_weight=_float_env("IRIS_KEYWORD_WEIGHT", 0.22),
min_speech_score=_float_env("IRIS_MIN_SPEECH_SCORE", 0.55),
min_visual_score=_float_env("IRIS_MIN_VISUAL_SCORE", 0.45),
)
def ensure_directories(self) -> None:
self.data_dir.mkdir(parents=True, exist_ok=True)
self.database_path.parent.mkdir(parents=True, exist_ok=True)
def resolve_device(device: str) -> str:
if device != "auto":
return device
try:
import torch
return "cuda" if torch.cuda.is_available() else "cpu"
except Exception:
return "cpu"
def transformers_pipeline_device(device: str) -> int:
resolved = resolve_device(device)
return 0 if resolved == "cuda" else -1
def resolve_torch_dtype(device: str, dtype: str):
normalized = dtype.strip().lower()
resolved_device = resolve_device(device)
if normalized == "auto":
normalized = "float16" if resolved_device == "cuda" else "float32"
try:
import torch
if normalized in {"float16", "fp16", "half"}:
return torch.float16
if normalized in {"bfloat16", "bf16"}:
return torch.bfloat16
if normalized in {"float32", "fp32", "full"}:
return torch.float32
except Exception:
pass
return "auto"
def device_info(device: str, dtype: str) -> dict:
resolved = resolve_device(device)
info = {
"requested_device": device,
"resolved_device": resolved,
"requested_dtype": dtype,
"cuda_available": False,
"cuda_version": None,
"gpu_count": 0,
"gpu_name": None,
}
try:
import torch
info.update(
{
"torch_version": torch.__version__,
"cuda_available": torch.cuda.is_available(),
"cuda_version": torch.version.cuda,
"gpu_count": torch.cuda.device_count(),
"gpu_name": torch.cuda.get_device_name(0) if torch.cuda.is_available() else None,
}
)
except Exception as exc:
info["torch_error"] = str(exc)
return info
def _optional_float_env(name: str) -> float | None:
value = os.getenv(name)
if value is None or value.strip() == "":
return None
return float(value)
|