[AI] [FEAT] 볼륨 마운트를 통한 가중치 저장 (#335)

* [AI] [FEAT] 볼륨 마운트를 통한 가중치 저장

* [AI] [FIX] xai 수정

* [AI] [FIX] 환경변수 정리

Author: twq110

.gitignore

@@ -32,6 +32,7 @@ AI/.venv/
 AI/data/weights/tcn/
 AI/config/trading.local.json
 AI/tests/out/
+AI/docs/
 
 # ===== Backend =====
 backend/src/main/java/org/sejongisc/backend/stock/TestController.java

AI/config/__init__.py

@@ -2,6 +2,7 @@
     CONFIG_ENV_VAR,
     DEFAULT_CONFIG_PATH,
     DEFAULT_LOCAL_CONFIG_PATH,
+    MODEL_WEIGHTS_DIR_ENV_VAR,
     DataConfig,
     ExecutionConfig,
     MacroFallbackConfig,
@@ -18,6 +19,7 @@
     "CONFIG_ENV_VAR",
     "DEFAULT_CONFIG_PATH",
     "DEFAULT_LOCAL_CONFIG_PATH",
+    "MODEL_WEIGHTS_DIR_ENV_VAR",
     "DataConfig",
     "ExecutionConfig",
     "MacroFallbackConfig",

AI/config/trading.py

@@ -11,6 +11,7 @@
 PROJECT_ROOT = Path(__file__).resolve().parents[2]
 CONFIG_DIR = Path(__file__).resolve().parent
 CONFIG_ENV_VAR = "AI_TRADING_CONFIG_PATH"
+MODEL_WEIGHTS_DIR_ENV_VAR = "AI_MODEL_WEIGHTS_DIR"
 DEFAULT_CONFIG_PATH = CONFIG_DIR / "trading.default.json"
 DEFAULT_LOCAL_CONFIG_PATH = CONFIG_DIR / "trading.local.json"
 
@@ -116,6 +117,11 @@ def _read_json(path: Path) -> dict[str, Any]:
 
 
 def _build_config(raw: dict[str, Any]) -> TradingConfig:
+    env_model_weights_dir = os.getenv(MODEL_WEIGHTS_DIR_ENV_VAR)
+    if env_model_weights_dir and env_model_weights_dir.strip():
+        model_weights_dir = env_model_weights_dir.strip()
+    else:
+        model_weights_dir = raw["model"]["weights_dir"]
     risk_overlay = RiskOverlayConfig(**raw["portfolio"]["risk_overlay"])
     macro_fallback = MacroFallbackConfig(**raw["pipeline"]["macro_fallback"])
     config = TradingConfig(
@@ -141,7 +147,7 @@ def _build_config(raw: dict[str, Any]) -> TradingConfig:
             prediction_horizons=tuple(raw["data"]["prediction_horizons"]),
         ),
         model=ModelConfig(
-            weights_dir=_resolve_path(raw["model"]["weights_dir"]),
+            weights_dir=_resolve_path(model_weights_dir),
             weights_file=raw["model"]["weights_file"],
             scaler_file=raw["model"]["scaler_file"],
         ),

AI/libs/llm/__init__.py

@@ -2,11 +2,20 @@
 from .base_client import BaseLLMClient
 from .groq import GroqClient
 from .ollama import OllamaClient
-from .gemini import GeminiClient
+
+try:
+    from .gemini import GeminiClient
+except Exception as gemini_import_error:
+    class GeminiClient:  # type: ignore[no-redef]
+        def __init__(self, *args, **kwargs):
+            raise ImportError(
+                "GeminiClient requires the `google-genai` package. "
+                "Install it with `pip install -U google-genai`."
+            ) from gemini_import_error
 
 __all__ = [
     "BaseLLMClient",
     "GroqClient",
     "OllamaClient",
     "GeminiClient"
-]
+]

AI/libs/llm/ollama.py

@@ -15,28 +15,68 @@ class OllamaClient(BaseLLMClient):
     def __init__(
         self,
         base_url: str = "http://localhost:11434",
-        model_name: str = os.environ.get("OLLAMA_MODEL", "llama3-ko"),
+        model_name: Optional[str] = None,
     ):
-        super().__init__(model_name=model_name)
+        env_model_name = os.environ.get("OLLAMA_MODEL")
+        resolved_model_name = model_name or env_model_name or "llama3:latest"
+        super().__init__(model_name=resolved_model_name)
         self.base_url = base_url
+        self._model_explicitly_set = bool(model_name or env_model_name)
+
+    def _list_local_models(self) -> list[str]:
+        try:
+            response = requests.get(f"{self.base_url}/api/tags", timeout=5)
+            response.raise_for_status()
+            result = response.json()
+            return [model.get("name", "") for model in result.get("models", []) if model.get("name")]
+        except Exception:
+            return []
+
+    def _ensure_model_available(self) -> bool:
+        local_models = self._list_local_models()
+        if not local_models:
+            self.set_last_error(
+                "No local Ollama model found. Pull one first (e.g. `ollama pull llama3:latest`)."
+            )
+            return False
+
+        if self.model_name in local_models:
+            return True
+
+        if self._model_explicitly_set:
+            self.set_last_error(
+                f"Model '{self.model_name}' is not installed. Installed models: {', '.join(local_models)}"
+            )
+            return False
+
+        fallback_model = local_models[0]
+        print(
+            f"[OllamaClient][Warning] Default model '{self.model_name}' is unavailable. "
+            f"Using '{fallback_model}' instead."
+        )
+        self.model_name = fallback_model
+        return True
 
     def generate_text(self, prompt: str, system_prompt: Optional[str] = None, **kwargs) -> str:
         url = f"{self.base_url}/api/generate"
-        full_prompt = prompt
-        if system_prompt:
-            full_prompt = f"System: {system_prompt}\n\nUser: {prompt}"
+
+        if not self._ensure_model_available():
+            print(f"[OllamaClient][Error] Text generation failed: {self.last_error}")
+            return ""
 
         payload = {
             "model": self.model_name,
-            "prompt": full_prompt,
+            "prompt": prompt,
             "stream": False,
             "options": {
                 "temperature": kwargs.get("temperature", 0.7),
             },
         }
+        if system_prompt:
+            payload["system"] = system_prompt
 
         try:
-            response = requests.post(url, json=payload)
+            response = requests.post(url, json=payload, timeout=kwargs.get("timeout", 120))
             response.raise_for_status()
             result = response.json()
             text = result.get("response", "")
@@ -49,8 +89,11 @@ def generate_text(self, prompt: str, system_prompt: Optional[str] = None, **kwar
 
     def get_health(self) -> bool:
         try:
-            res = requests.get(self.base_url, timeout=5)
-            return res.status_code == 200
+            res = requests.get(f"{self.base_url}/api/tags", timeout=5)
+            is_healthy = res.status_code == 200
+            if is_healthy:
+                self.clear_last_error()
+            return is_healthy
         except Exception as e:
             self.set_last_error(e)
             return False

AI/modules/signal/core/__init__.py

@@ -1,8 +1,20 @@
 # AI/modules/signal/core/__init__.py
 from .base_model import BaseSignalModel
 from .data_loader import DataLoader
+from .artifact_paths import (
+    ARTIFACT_ROOT_ENV_VAR,
+    ModelArtifactPaths,
+    resolve_artifact_file,
+    resolve_artifact_root,
+    resolve_model_artifacts,
+)
 
 __all__ = [
+    "ARTIFACT_ROOT_ENV_VAR",
     "BaseSignalModel",
     "DataLoader",
-]
+    "ModelArtifactPaths",
+    "resolve_artifact_file",
+    "resolve_artifact_root",
+    "resolve_model_artifacts",
+]

AI/modules/signal/core/artifact_paths.py

@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+
+ARTIFACT_ROOT_ENV_VAR = "AI_MODEL_WEIGHTS_DIR"
+DEFAULT_ARTIFACT_ROOT = Path("AI/data/weights")
+PROJECT_ROOT = Path(__file__).resolve().parents[4]
+
+
+@dataclass(frozen=True, slots=True)
+class ModelArtifactPaths:
+    root_dir: str
+    model_dir: str
+    model_path: str
+    scaler_path: str | None = None
+    metadata_path: str | None = None
+
+
+def _resolve_absolute(raw_path: str | Path) -> Path:
+    path = Path(raw_path)
+    if not path.is_absolute():
+        path = PROJECT_ROOT / path
+    return path.resolve()
+
+
+def _normalize_mode(raw_mode: str | None) -> str:
+    mode = (raw_mode or "prod").strip().lower()
+    if mode in {"simulation", "sim", "test", "tests", "dev", "development", "qa"}:
+        return "tests"
+    if mode in {"live", "production", "prod"}:
+        return "prod"
+    return mode
+
+
+def resolve_artifact_root(config_weights_dir: str | None = None) -> str:
+    env_root = os.getenv(ARTIFACT_ROOT_ENV_VAR)
+    selected_root = (
+        env_root.strip()
+        if env_root and env_root.strip()
+        else (config_weights_dir or str(DEFAULT_ARTIFACT_ROOT))
+    )
+    return str(_resolve_absolute(selected_root))
+
+
+def resolve_artifact_file(*relative_parts: str, config_weights_dir: str | None = None) -> str:
+    if not relative_parts:
+        raise ValueError("At least one path part is required.")
+    artifact_root = Path(resolve_artifact_root(config_weights_dir))
+    return str((artifact_root.joinpath(*relative_parts)).resolve())
+
+
+def resolve_model_artifacts(
+    model_name: str,
+    mode: str | None = None,
+    config_weights_dir: str | None = None,
+    model_dir: str | None = None,
+) -> ModelArtifactPaths:
+    normalized_model = model_name.strip().lower()
+    normalized_mode = _normalize_mode(mode)
+    root_dir = Path(resolve_artifact_root(config_weights_dir))
+
+    if normalized_model == "transformer":
+        suffix = "_prod"
+        mode_dir = "prod"
+        if normalized_mode == "tests":
+            suffix = "_test"
+            mode_dir = "tests"
+
+        resolved_model_dir = _resolve_absolute(model_dir) if model_dir else (root_dir / "transformer" / mode_dir)
+        model_path = resolved_model_dir / f"multi_horizon_model{suffix}.keras"
+        scaler_path = resolved_model_dir / f"multi_horizon_scaler{suffix}.pkl"
+        return ModelArtifactPaths(
+            root_dir=str(root_dir),
+            model_dir=str(resolved_model_dir),
+            model_path=str(model_path),
+            scaler_path=str(scaler_path),
+            metadata_path=None,
+        )
+
+    if normalized_model in {"itransformer", "i_transformer", "i-transformer"}:
+        resolved_model_dir = _resolve_absolute(model_dir) if model_dir else (root_dir / "itransformer")
+        return ModelArtifactPaths(
+            root_dir=str(root_dir),
+            model_dir=str(resolved_model_dir),
+            model_path=str(resolved_model_dir / "multi_horizon_model.keras"),
+            scaler_path=str(resolved_model_dir / "multi_horizon_scaler.pkl"),
+            metadata_path=str(resolved_model_dir / "metadata.json"),
+        )
+
+    if normalized_model == "tcn":
+        resolved_model_dir = _resolve_absolute(model_dir) if model_dir else (root_dir / "tcn")
+        return ModelArtifactPaths(
+            root_dir=str(root_dir),
+            model_dir=str(resolved_model_dir),
+            model_path=str(resolved_model_dir / "model.pt"),
+            scaler_path=str(resolved_model_dir / "scaler.pkl"),
+            metadata_path=str(resolved_model_dir / "metadata.json"),
+        )
+
+    if normalized_model == "patchtst":
+        resolved_model_dir = _resolve_absolute(model_dir) if model_dir else (root_dir / "patchtst")
+        return ModelArtifactPaths(
+            root_dir=str(root_dir),
+            model_dir=str(resolved_model_dir),
+            model_path=str(resolved_model_dir / "PatchTST_best.pt"),
+            scaler_path=None,
+            metadata_path=None,
+        )
+
+    raise ValueError(f"Unsupported model name for artifact resolution: {model_name}")

AI/modules/signal/models/PatchTST/train.py

@@ -6,6 +6,19 @@
 import os
 from torch.utils.data import DataLoader, TensorDataset
 from .architecture import PatchTST_Model
+from AI.config import load_trading_config
+from AI.modules.signal.core.artifact_paths import resolve_model_artifacts
+
+
+def _default_model_save_path() -> str:
+    try:
+        trading_config = load_trading_config()
+        return resolve_model_artifacts(
+            model_name="patchtst",
+            config_weights_dir=trading_config.model.weights_dir,
+        ).model_path
+    except Exception:
+        return resolve_model_artifacts(model_name="patchtst").model_path
 
 # 설정값
 CONFIG = {
@@ -15,7 +28,7 @@
     'learning_rate': 0.0001,
     'epochs': 100,
     'patience': 10,
-    'model_save_path': 'AI/data/weights/PatchTST_best.pt'
+    'model_save_path': _default_model_save_path()
 }
 
 def train_model(train_loader, val_loader, device):
@@ -100,4 +113,4 @@ def run_training(X_train, y_train, X_val, y_val):
     val_loader = DataLoader(val_data, batch_size=CONFIG['batch_size'], shuffle=False)
 
     trained_model = train_model(train_loader, val_loader, device)
-    return trained_model
+    return trained_model