Spaces용 코드만 포함 (모델 파일 제외)

.dockerignore

@@ -0,0 +1,22 @@
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.so
+*.egg
+*.egg-info
+dist
+build
+.git
+.gitignore
+.env
+.venv
+venv/
+ENV/
+env/
+.vscode
+.idea
+*.md
+!README.md
+

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,62 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+
+# Model files (큰 파일이므로 Git에서 제외)
+*.pth
+*.pt
+*.ckpt
+*.bin
+*.safetensors
+*.tflite
+*.keras
+*.h5
+*.pb
+*.onnx
+*.pkl
+*.pickle
+
+# Model directory
+model/
+

Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+ENV PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1
+
+COPY requirements.txt .
+RUN apt-get update && apt-get install -y --no-install-recommends build-essential && \
+    pip install --upgrade pip && \
+    pip install -r requirements.txt && \
+    apt-get purge -y build-essential && apt-get autoremove -y && rm -rf /var/lib/apt/lists/*
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+

README.md

@@ -0,0 +1,92 @@
+---
+title: MuscleCare Train AI
+emoji: 🔥
+colorFrom: green
+colorTo: purple
+sdk: docker
+pinned: false
+license: apache-2.0
+---
+
+# MuscleCare Train AI
+
+CNN + GRU 기반 근육 피로도 예측 모델 자동 학습 시스템
+
+## 🚀 주요 기능
+
+- **자동 데이터 로딩**: Hugging Face `Merry99/MuscleCare-DataSet` 데이터셋 자동 로드
+- **CNN + GRU 모델**: 시퀀스 데이터에서 피로도 예측
+- **자동 학습 스케줄링**: 매주 일요일 자정 자동 모델 업데이트
+- **중복 방지**: 이미 학습된 세션 데이터 자동 제외
+- **TFLite 변환**: 모바일 배포를 위한 TFLite 모델 자동 생성 (필수)
+
+## 📦 실행 방법
+
+### Docker 사용 (권장)
+
+```bash
+# 이미지 빌드
+docker build -t musclecare-train-ai .
+
+# 실행
+docker run musclecare-train-ai
+```
+
+### 로컬 실행 (Python 3.10 필요)
+
+```bash
+# Python 3.10 확인
+python3.10 --version
+
+# 패키지 설치
+python3.10 -m pip install -r requirements.txt
+
+# 실행
+python3.10 start.py
+```
+
+또는 스크립트 사용:
+```bash
+./run_local.sh
+```
+
+## 🔄 전체 플로우
+
+1. **데이터 로드**: `load_dataset.py`로 Hugging Face 데이터셋 로드
+2. **모델 학습**: `train_e2e.py`로 CNN + GRU 모델 학습
+3. **모델 저장**: 학습된 모델을 `./model/fatigue_net_v2.pt`에 저장 (PyTorch state_dict 형식)
+4. **TFLite 변환**: `convert_tflite.py`로 TFLite 모델 생성 → `./model/fatigue_net_v2.tflite`
+
+## 📁 파일 구조
+
+- `load_dataset.py`: Hugging Face 데이터셋 로드
+- `train_e2e.py`: CNN + GRU 모델 학습 (PyTorch state_dict 형식으로 저장)
+- `convert_tflite.py`: PyTorch → TFLite 변환
+- `train_scheduler.py`: 자동 학습 스케줄러
+- `start.py`: 자동 학습 스케줄러 시작 스크립트
+- `app.py`: FastAPI 애플리케이션 (나중에 구현 예정)
+
+## 🔧 요구사항
+
+- Python 3.10 (TFLite 변환 필수)
+- PyTorch 2.0+
+- ONNX, ONNX-TF, TensorFlow (TFLite 변환용)
+
+## 📝 모델 저장 위치
+
+- PyTorch 모델: `./model/fatigue_net_v2.pt` (state_dict 형식)
+- **TFLite 모델: `./model/fatigue_net_v2.tflite`** (모바일 배포용, 필수)
+- 학습 상태: `./model/training_state.json`
+
+## ⚠️ 중요 사항
+
+- **TFLite 변환은 필수입니다** (모바일 디바이스에서 실행 필요)
+- 모델은 반드시 PyTorch state_dict 형식으로 저장되어야 합니다 (TorchScript 형식 불가)
+- Python 3.10 이상이 필요합니다 (TFLite 변환 패키지 호환성)
+
+## 🔄 자동 학습 스케줄
+
+- 실행 시간: 매주 일요일 자정 (00:00)
+- 중복 방지: `training_state.json`에 저장된 세션 ID는 자동 제외
+- 모델 버전: 자동 증가
+- TFLite 변환: 학습 후 자동 수행

app.py

@@ -0,0 +1,262 @@
+"""FastAPI 앱: 수동 학습 및 Hugging Face 업로드 트리거"""
+
+from __future__ import annotations
+
+import json
+import os
+import threading
+import time
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import schedule
+from fastapi import FastAPI, HTTPException
+from fastapi.responses import FileResponse
+from huggingface_hub import HfApi, hf_hub_download
+try:
+    from huggingface_hub.utils import HfHubHTTPError
+except ImportError:  # pragma: no cover
+    HfHubHTTPError = Exception  # type: ignore
+from pydantic import BaseModel
+
+from train_scheduler import TrainingScheduler
+
+
+app = FastAPI(
+    title="MuscleCare Train Scheduler API",
+    description="수동으로 모델 학습 및 Hugging Face 업로드를 트리거합니다.",
+)
+
+_scheduler = TrainingScheduler()
+
+
+class TrainResponse(BaseModel):
+    status: str
+    new_data_count: int
+    model_path: Optional[str] = None
+    hub_url: Optional[str] = None
+    model_version: Optional[int] = None
+    message: str
+
+
+@app.on_event("startup")
+def startup_training() -> None:
+    """서버 시작 시 자동으로 모델 학습을 실행합니다."""
+    try:
+        print("🚀 서버 시작: 자동 모델 학습을 시작합니다...")
+        result = _scheduler.run_scheduled_training()
+        if result["status"] == "trained":
+            print(f"✅ 서버 시작 시 학습 완료: {result['new_data_count']}개 데이터로 학습됨")
+        else:
+            print(f"ℹ️ 서버 시작 시 학습 건너뜀: {result.get('message', '새로운 데이터 없음')}")
+    except Exception as exc:
+        print(f"⚠️ 서버 시작 시 학습 실패: {exc}")
+
+    # 기존 스케줄링 설정
+    schedule.clear()
+    schedule.every().sunday.at("00:00").do(_scheduler.run_scheduled_training)
+
+    def _run_schedule() -> None:
+        while True:
+            schedule.run_pending()
+            time.sleep(60)
+
+    threading.Thread(target=_run_schedule, daemon=True).start()
+
+
+@app.get("/health")
+def health_check() -> dict:
+    return {"status": "ok"}
+
+
+@app.get("/")
+def root() -> dict:
+    return {
+        "message": "MuscleCare Train Scheduler API가 실행 중입니다.",
+        "endpoints": {
+            "health": "/health",
+            "trigger": "/trigger",
+        },
+        "docs": "/docs",
+    }
+
+
+def _upload_to_hub(model_path: str) -> Optional[str]:
+    token = os.getenv("HF_E2E_MODEL_TOKEN")
+    repo_id = os.getenv("HF_E2E_MODEL_REPO_ID")
+
+    if not token or not repo_id:
+        raise HTTPException(
+            status_code=400,
+            detail="환경 변수 HF_E2E_MODEL_TOKEN / HF_E2E_MODEL_REPO_ID가 설정되어 있지 않습니다.",
+        )
+
+    path = Path(model_path)
+    if not path.exists():
+        raise HTTPException(status_code=404, detail=f"모델 파일을 찾을 수 없습니다: {model_path}")
+
+    api = HfApi(token=token)
+    api.create_repo(repo_id=repo_id, repo_type="model", private=False, exist_ok=True)
+
+    api.upload_file(
+        path_or_fileobj=path,
+        path_in_repo=path.name,
+        repo_id=repo_id,
+        repo_type="model",
+        commit_message="Manual scheduler trigger upload",
+    )
+
+    return f"https://huggingface.co/{repo_id}"
+
+
+# TODO: include version info in response body
+@app.get("/model")
+@app.get("/model/{version:int}")
+def download_model(
+    version: Optional[int] = None,
+    filename: Optional[str] = None
+) -> FileResponse:
+    repo_id = os.getenv("HF_E2E_MODEL_REPO_ID")
+    token = os.getenv("HF_E2E_MODEL_TOKEN")
+    default_filename = os.getenv("HF_E2E_MODEL_FILE", "cnn_gru_fatigue.tflite")
+
+    if not repo_id:
+        raise HTTPException(
+            status_code=400,
+            detail="환경 변수 HF_E2E_MODEL_REPO_ID가 설정되어 있지 않습니다."
+        )
+
+    current_state = _scheduler.load_training_state()
+    current_version = int(current_state.get("model_version", 0) or 0)
+
+    try:
+        if not version:
+            target_filename = filename or default_filename
+            local_path = hf_hub_download(
+                repo_id=repo_id,
+                filename=target_filename,
+                repo_type="model",
+                token=token,
+                local_dir="./model_cache",
+                local_dir_use_symlinks=False,
+            )
+            actual_version = current_version
+        else:
+            if version > current_version:
+                raise HTTPException(
+                    status_code=404,
+                    detail=f"현재 모델 버전은 {current_version}입니다. 버전 {version}은 존재하지 않습니다."
+                )
+            manifest_path = hf_hub_download(
+                repo_id=repo_id,
+                filename="model_versions.json",
+                repo_type="model",
+                token=token,
+                local_dir="./model_cache",
+                local_dir_use_symlinks=False,
+            )
+            with open(manifest_path, "r", encoding="utf-8") as f:
+                manifest = json.load(f)
+
+            version_entry = next(
+                (entry for entry in manifest if entry.get("version") == version),
+                None
+            )
+
+            if version_entry is None:
+                raise HTTPException(
+                    status_code=404,
+                    detail=f"버전 {version}에 해당하는 모델을 찾을 수 없습니다."
+                )
+
+            target_filename = filename or version_entry.get("filename")
+            target_revision = version_entry.get("commit")
+
+            if not target_filename or not target_revision:
+                raise HTTPException(
+                    status_code=500,
+                    detail=f"버전 {version} 메타데이터가 올바르지 않습니다."
+                )
+
+            local_path = hf_hub_download(
+                repo_id=repo_id,
+                filename=target_filename,
+                repo_type="model",
+                token=token,
+                local_dir="./model_cache",
+                local_dir_use_symlinks=False,
+                revision=target_revision,
+            )
+            actual_version = version
+    except Exception as exc:
+        status = getattr(getattr(exc, "response", None), "status_code", None)
+        if status == 404:
+            raise HTTPException(
+                status_code=404,
+                detail="허깅페이스에서 지정한 모델 파일을 찾을 수 없습니다."
+            ) from exc
+        raise HTTPException(
+            status_code=500,
+            detail=f"Hugging Face Hub 다운로드 실패: {exc}"
+        ) from exc
+
+    response = FileResponse(
+        path=local_path,
+        filename=Path(target_filename).name,
+        media_type="application/octet-stream"
+    )
+    response.headers["X-Model-Version"] = str(actual_version)
+    response.headers["X-Model-Filename"] = Path(target_filename).name
+    return response
+
+
+class ResetStateResponse(BaseModel):
+    status: str
+    state: Dict[str, Any]
+
+
+@app.post("/state/reset", response_model=ResetStateResponse)
+def reset_training_state() -> ResetStateResponse:
+    try:
+        state = _scheduler.reset_training_state()
+        return ResetStateResponse(
+            status="reset",
+            state=state,
+        )
+    except Exception as exc:  # pylint: disable=broad-except
+        raise HTTPException(status_code=500, detail=f"학습 상태 초기화에 실패했습니다: {exc}") from exc
+
+
+@app.post("/trigger", response_model=TrainResponse)
+def trigger_training(upload: bool = True) -> TrainResponse:
+    try:
+        result = _scheduler.run_scheduled_training()
+    except Exception as exc:  # pylint: disable=broad-except
+        raise HTTPException(status_code=500, detail=f"학습 실행 중 오류가 발생했습니다: {exc}") from exc
+
+    message = "새로운 데이터가 없어 학습을 건너뜁니다."
+    hub_url = None
+
+    if result["status"] == "trained":
+        message = "모델 학습이 완료되었습니다."
+        model_path = result.get("model_path")
+
+        if upload and model_path:
+            try:
+                hub_url = _upload_to_hub(model_path)
+                message = "모델 학습 및 업로드가 완료되었습니다."
+            except HTTPException:
+                raise
+            except Exception as exc:  # pylint: disable=broad-except
+                raise HTTPException(status_code=500, detail=f"Hugging Face 업로드 실패: {exc}") from exc
+
+    return TrainResponse(
+        status=result["status"],
+        new_data_count=result["new_data_count"],
+        model_path=result.get("model_path"),
+        hub_url=hub_url,
+        message=message,
+    )
+
+
+__all__ = ["app"]

convert_tflite.py

@@ -0,0 +1,336 @@
+"""
+PyTorch 모델을 TensorFlow Lite 형식으로 변환하는 스크립트
+"""
+
+import torch
+import torch.nn as nn
+import numpy as np
+import os
+
+# 선택적 임포트
+ONNX_AVAILABLE = False
+TF_AVAILABLE = False
+ONNX_TF_AVAILABLE = False
+
+try:
+    import onnx
+    ONNX_AVAILABLE = True
+except (ImportError, SyntaxError, Exception) as e:
+    ONNX_AVAILABLE = False
+    if not isinstance(e, ImportError):
+        print(f"⚠️  onnx 패키지 로드 중 오류 발생: {type(e).__name__}")
+
+try:
+    import tensorflow as tf
+    TF_AVAILABLE = True
+except (ImportError, SyntaxError, Exception) as e:
+    TF_AVAILABLE = False
+    if not isinstance(e, ImportError):
+        print(f"⚠️  tensorflow 패키지 로드 중 오류 발생: {type(e).__name__}")
+
+try:
+    # onnx-tf는 실제로 사용할 때 임포트하도록 변경
+    # from onnx_tf.backend import prepare
+    ONNX_TF_AVAILABLE = True
+except (ImportError, SyntaxError, Exception) as e:
+    ONNX_TF_AVAILABLE = False
+    if not isinstance(e, ImportError):
+        print(f"⚠️  onnx-tf 패키지 로드 중 오류 발생: {type(e).__name__}")
+
+
+class FatigueNet(nn.Module):
+    """CNN + GRU 기반 피로도 예측 모델 (PyTorch 버전)"""
+    
+    def __init__(self, input_dim=2, hidden_dim=64, num_layers=2, output_dim=1):
+        super(FatigueNet, self).__init__()
+        
+        # CNN 부분
+        self.conv1 = nn.Conv1d(
+            in_channels=input_dim,
+            out_channels=32,
+            kernel_size=1,
+            padding=0
+        )
+        self.conv2 = nn.Conv1d(
+            in_channels=32,
+            out_channels=64,
+            kernel_size=1,
+            padding=0
+        )
+        self.relu = nn.ReLU()
+        
+        # GRU 부분 (TFLite 호환성을 위해 linear_before_reset=False)
+        self.gru = nn.GRU(
+            input_size=64,
+            hidden_size=hidden_dim,
+            num_layers=num_layers,
+            batch_first=True,
+            dropout=0.2 if num_layers > 1 else 0
+        )
+        
+        # Fully Connected 레이어
+        self.fc = nn.Linear(hidden_dim, output_dim)
+        self.dropout = nn.Dropout(0.3)
+    
+    def forward(self, x):
+        if x.dim() == 2:
+            x = x.unsqueeze(1)
+        
+        x = x.permute(0, 2, 1)
+        
+        x = self.conv1(x)
+        x = self.relu(x)
+        
+        x = self.conv2(x)
+        x = self.relu(x)
+        
+        x = x.permute(0, 2, 1)
+        
+        gru_out, _ = self.gru(x)
+        
+        last_output = gru_out[:, -1, :]
+        
+        last_output = self.dropout(last_output)
+        output = self.fc(last_output)
+        
+        return output
+
+
+def convert_pytorch_to_tflite(
+    pytorch_model_path='./model/fatigue_net_v2.pt',
+    tflite_model_path='./model/fatigue_net_v2.tflite',
+    input_shape=(1, 1, 2)  # (batch, seq_len, features)
+):
+    """
+    PyTorch 모델을 TensorFlow Lite로 변환
+    
+    Args:
+        pytorch_model_path: PyTorch 모델 파일 경로
+        tflite_model_path: 저장할 TFLite 모델 파일 경로
+        input_shape: 입력 텐서 형태 (batch, seq_len, features)
+    """
+    print("=" * 80)
+    print("PyTorch 모델을 TensorFlow Lite로 변환")
+    print("=" * 80)
+    
+    # 필수 패키지 확인
+    if not ONNX_AVAILABLE or not TF_AVAILABLE or not ONNX_TF_AVAILABLE:
+        print("\n❌ 필수 패키지가 설치되지 않았거나 호환성 문제가 있습니다.")
+        print("\n📋 Python 버전 확인:")
+        import sys
+        print(f"   현재 Python 버전: {sys.version}")
+        print(f"   권장 Python 버전: 3.10 이상")
+        
+        if sys.version_info < (3, 10):
+            print("\n⚠️  Python 3.9에서는 일부 패키지 호환성 문제가 있을 수 있습니다.")
+            print("   Python 3.10 이상으로 업그레이드하거나, 다음을 시도하세요:")
+            print("   - 가상환경에서 Python 3.10+ 사용")
+            print("   - 또는 호환되는 패키지 버전 설치")
+        
+        print("\n📦 설치 명령어:")
+        print("  권장 버전 (Python 3.10 이상):")
+        print("    pip install onnx==1.15.0 onnx-tf==1.10.0 tensorflow==2.15.0")
+        print("\n⚠️  참고: Python 3.9에서는 일부 패키지 설치 중 에러가 발생할 수 있습니다.")
+        print("   Python 3.10 이상 사용을 강력히 권장합니다.")
+        
+        print("\n❌ TFLite 변환은 필수입니다. 모바일 디바이스에서 실행하기 위해 필요합니다.")
+        print("   필수 패키지를 설치하고 다시 시도하세요.")
+        return False
+    
+    # 1️⃣ PyTorch 모델 로드
+    print("\n1️⃣ PyTorch 모델 로드 중...")
+    if not os.path.exists(pytorch_model_path):
+        raise FileNotFoundError(f"모델 파일을 찾을 수 없습니다: {pytorch_model_path}")
+    
+    # TorchScript 파일인지 먼저 확인
+    try:
+        checkpoint = torch.jit.load(pytorch_model_path, map_location='cpu')
+        if isinstance(checkpoint, torch.jit.ScriptModule):
+            raise ValueError(
+                f"❌ {pytorch_model_path}는 TorchScript 형식입니다.\n"
+                "TFLite 변환을 위해서는 PyTorch state_dict 형식 모델이 필요합니다.\n"
+                "모델을 다시 학습하거나 올바른 형식의 모델 파일을 사용하세요."
+            )
+    except:
+        pass
+    
+    # 일반 PyTorch 모델 로드
+    checkpoint = torch.load(pytorch_model_path, map_location='cpu')
+    
+    # 일반 PyTorch 모델인지 확인
+    if not isinstance(checkpoint, dict) or 'model_state_dict' not in checkpoint:
+        raise ValueError(
+            f"❌ 올바른 PyTorch 모델 형식이 아닙니다.\n"
+            f"'{pytorch_model_path}' 파일에 'model_state_dict' 키가 필요합니다.\n"
+            "모델을 다시 학습하거나 올바른 형식의 모델 파일을 사용하세요."
+        )
+    
+    model_config = checkpoint.get('model_config', {
+        'input_dim': 2,
+        'hidden_dim': 64,
+        'num_layers': 2,
+        'output_dim': 1
+    })
+    
+    model = FatigueNet(**model_config)
+    model.load_state_dict(checkpoint['model_state_dict'])
+    model.eval()
+    print(f"✅ 모델 로드 완료: {pytorch_model_path}")
+    print(f"   모델 설정: {model_config}\n")
+    
+    # 2️⃣ ONNX로 변환
+    print("2️⃣ ONNX 형식으로 변환 중...")
+    onnx_model_path = './model/fatigue_net_v2.onnx'
+    os.makedirs('./model', exist_ok=True)
+    
+    # 더미 입력 생성 (고정 batch_size=1로 TFLite 호환성 향상)
+    dummy_input = torch.randn(1, 1, 2)  # (batch=1, seq_len=1, features=2)
+    
+    try:
+        # GRU를 RNN으로 변환하거나 TFLite 호환 옵션 사용
+        torch.onnx.export(
+            model,
+            dummy_input,
+            onnx_model_path,
+            export_params=True,
+            opset_version=11,  # onnx-tf 호환성을 위해 11로 낮춤
+            do_constant_folding=True,
+            input_names=['input'],
+            output_names=['output'],
+            dynamic_axes={
+                'input': {0: 'batch_size', 1: 'sequence_length'},
+                'output': {0: 'batch_size'}
+            },
+            # GRU 관련 호환성 옵션
+            custom_opsets=None,
+            verbose=False
+        )
+        print(f"✅ ONNX 변환 완료: {onnx_model_path}\n")
+    except Exception as e:
+        print(f"⚠️  ONNX 변환 중 경고 (계속 진행): {e}\n")
+    
+    # 3️⃣ ONNX를 TensorFlow로 변환
+    print("3️⃣ TensorFlow 형식으로 변환 중...")
+    try:
+        from onnx_tf.backend import prepare
+        
+        # ONNX 모델 로드 및 GRU 속성 수정
+        onnx_model = onnx.load(onnx_model_path)
+        
+        # GRU 노드의 linear_before_reset 속성을 0으로 설정 (TensorFlow 호환)
+        for node in onnx_model.graph.node:
+            if node.op_type == 'GRU':
+                # linear_before_reset 속성을 찾아서 0으로 설정
+                for attr in node.attribute:
+                    if attr.name == 'linear_before_reset':
+                        attr.i = 0
+                        break
+                else:
+                    # linear_before_reset 속성이 없으면 추가
+                    attr = onnx.helper.make_attribute('linear_before_reset', 0)
+                    node.attribute.append(attr)
+        
+        tf_rep = prepare(onnx_model)
+        
+        # TensorFlow SavedModel로 저장
+        tf_model_path = './model/tf_model'
+        tf_rep.export_graph(tf_model_path)
+        print(f"✅ TensorFlow 변환 완료: {tf_model_path}\n")
+    except Exception as e:
+        print(f"❌ TensorFlow 변환 실패: {e}")
+        print("⚠️  ONNX-TF 변환이 실패했습니다.\n")
+        print("❌ TFLite 변환은 필수입니다. 모바일 디바이스에서 실행하기 위해 필요합니다.")
+        print("   에러를 해결하고 다시 시도하세요.")
+        return False
+    
+    # 4️⃣ TensorFlow Lite로 변환
+    print("4️⃣ TensorFlow Lite 형식으로 변환 중...")
+    
+    # TensorFlow Lite 변환기 생성
+    converter = tf.lite.TFLiteConverter.from_saved_model(tf_model_path)
+    
+    # GRU 등 복잡한 연산을 위한 설정
+    converter.target_spec.supported_ops = [
+        tf.lite.OpsSet.TFLITE_BUILTINS,
+        tf.lite.OpsSet.SELECT_TF_OPS
+    ]
+    converter._experimental_lower_tensor_list_ops = False
+    
+    # 최적화 옵션 설정 (선택사항)
+    converter.optimizations = [tf.lite.Optimize.DEFAULT]
+    
+    # 변환 실행
+    tflite_model = converter.convert()
+    
+    # TFLite 모델 저장
+    with open(tflite_model_path, 'wb') as f:
+        f.write(tflite_model)
+    
+    print(f"✅ TensorFlow Lite 변환 완료: {tflite_model_path}")
+    
+    # 모델 크기 확인
+    model_size = os.path.getsize(tflite_model_path) / (1024 * 1024)  # MB
+    print(f"   모델 크기: {model_size:.2f} MB\n")
+    
+    # 5️⃣ 변환된 모델 테스트
+    print("5️⃣ 변환된 모델 테스트 중...")
+    try:
+        interpreter = tf.lite.Interpreter(model_path=tflite_model_path)
+        interpreter.allocate_tensors()
+        
+        input_details = interpreter.get_input_details()
+        output_details = interpreter.get_output_details()
+        
+        print(f"   입력 형태: {input_details[0]['shape']}")
+        print(f"   출력 형태: {output_details[0]['shape']}")
+        
+        # 테스트 입력 (고정 크기)
+        test_input = np.random.randn(1, 1, 2).astype(np.float32)
+        interpreter.set_tensor(input_details[0]['index'], test_input)
+        interpreter.invoke()
+        test_output = interpreter.get_tensor(output_details[0]['index'])
+        
+        print(f"   테스트 출력: {test_output[0][0]:.4f}")
+        print("   ✅ 모델 테스트 성공\n")
+    except Exception as e:
+        print(f"   ⚠️  모델 테스트 중 경고: {e}")
+        print("   (모델은 생성되었지만 테스트는 실패했습니다. 모바일 디바이스에서 Flex ops가 필요할 수 있습니다.)\n")
+    
+    # 중간 파일 정리 (선택사항)
+    print("6️⃣ 중간 파일 정리 중...")
+    try:
+        os.remove(onnx_model_path)
+        import shutil
+        shutil.rmtree(tf_model_path)
+        print("✅ 중간 파일 정리 완료\n")
+    except Exception as e:
+        print(f"⚠️  중간 파일 정리 실패 (무시 가능): {e}\n")
+    
+    print("=" * 80)
+    print(f"✅ 변환 완료!")
+    print(f"   TFLite 모델: {tflite_model_path}")
+    print("=" * 80)
+    return True
+
+
+def main():
+    """메인 함수"""
+    try:
+        success = convert_pytorch_to_tflite(
+            pytorch_model_path='./model/fatigue_net_v2.pt',
+            tflite_model_path='./model/fatigue_net_v2.tflite'
+        )
+        if not success:
+            return 1
+    except Exception as e:
+        print(f"\n❌ 변환 실패: {e}")
+        import traceback
+        traceback.print_exc()
+        return 1
+    
+    return 0
+
+
+if __name__ == "__main__":
+    exit(main())
+

load_dataset.py

@@ -0,0 +1,38 @@
+"""
+Hugging Face 데이터셋 로드 유틸리티
+MuscleCare-DataSet 데이터셋을 로드하는 함수들을 제공합니다.
+"""
+
+from datasets import load_dataset
+from typing import Optional
+
+
+def load_musclecare_dataset(
+    split: Optional[str] = None,
+    cache_dir: Optional[str] = None
+):
+    """
+    MuscleCare-DataSet 데이터셋을 로드합니다.
+    
+    Args:
+        split: 데이터셋 split 이름 (None이면 모든 split 로드)
+        cache_dir: 캐시 디렉토리 경로
+    
+    Returns:
+        Dataset 또는 DatasetDict 객체
+    """
+    dataset = load_dataset(
+        "Merry99/MuscleCare-DataSet",
+        split=split,
+        cache_dir=cache_dir
+    )
+    return dataset
+
+if __name__ == "__main__":
+    print("데이터셋 로딩 중...")
+    dataset = load_musclecare_dataset()
+    print("✅ 데이터셋 로드 완료")
+    if hasattr(dataset, 'keys'):
+        print(f"총 {len(dataset.keys())}개의 split이 있습니다.")
+
+

model.md

@@ -0,0 +1,127 @@
+## `/model` API
+
+모델 다운로드 엔드포인트는 최신 모델과 특정 버전의 모델을 모두 제공하며, 응답 헤더를 통해 실제 버전 정보를 확인할 수 있습니다.
+
+### 요청 형식
+
+```
+GET /model
+GET /model?version={번호}
+GET /model?version={번호}&filename={파일명}
+```
+
+| 파라미터 | 타입 | 설명 |
+| --- | --- | --- |
+| `version` (선택) | int | 생략하거나 빈 값이면 최신 모델. 지정하면 해당 버전 확인 후 다운로드. |
+| `filename` (선택) | string | 내려받을 파일명. 기본값은 환경 변수 `HF_E2E_MODEL_FILE` (기본 `cnn_gru_fatigue.tflite`). |
+
+### 응답
+
+- 본문: 요청한 모델 바이너리 (예: `.tflite`, `.keras`, 메타데이터 등)
+- 헤더:
+  - `X-Model-Version`: 실제 다운로드된 모델 버전
+  - `X-Model-Filename`: 반환된 파일명
+- 에러:
+  - `404` – 요청한 버전이 현재 `model_version`보다 크거나 manifest에 존재하지 않을 때
+  - `500` – Hugging Face Hub 다운로드 실패 등 내부 오류
+
+### 동작 규칙
+
+1. 서버는 `training_state.json`의 `model_version` 값을 읽어 현재 허용 가능한 최대 버전을 확인합니다.
+2. `version`을 지정하지 않으면 최신 모델(현재 버전)을 다운로드합니다.
+3. `version`을 지정하면 서버가 현재 `model_version` 이하인지 확인한 뒤, 동일한 파일명을 내려줍니다(버전별로 파일명을 구분하지 않습니다).
+4. 요청한 버전이 현재 버전보다 크거나 파일이 존재하지 않으면 `404`를 반환합니다.
+
+### 사용 예시
+
+#### 최신 모델 다운로드
+```bash
+curl -L -o cnn_gru_fatigue_latest.tflite \
+  "https://merry99-musclecare-train-ai.hf.space/model"
+```
+
+#### 버전 3 모델 다운로드
+```bash
+curl -L -o cnn_gru_fatigue_v3.tflite \
+  "https://merry99-musclecare-train-ai.hf.space/model?version=3"
+```
+
+#### 버전 3 메타데이터 다운로드
+```bash
+curl -L -o metadata_v3.json \
+  "https://merry99-musclecare-train-ai.hf.space/model?version=3&filename=cnn_gru_fatigue_metadata.json"
+```
+
+#### 헤더 확인
+```bash
+curl -I "https://merry99-musclecare-train-ai.hf.space/model?version=3"
+```
+응답 헤더 예시:
+```
+X-Model-Version: 3
+X-Model-Filename: cnn_gru_fatigue.tflite
+```
+
+### 주의 사항
+
+- `training_state.json`의 `model_version` 값이 기준이 되며, 그보다 높은 버전을 요청하면 404가 반환됩니다.
+- 버전별로 다른 파일을 유지하지 않고, 같은 파일명을 내려주되 헤더(`X-Model-Version`)로 실제 버전을 확인합니다.
+- 실패(예: 404) 시 JSON 응답이 내려오므로, 클라이언트는 상태 코드를 먼저 확인한 뒤 **200일 때만** `body`를 파일로 저장하세요.
+
+Flutter 예시 (Dio):
+```dart
+final response = await dio.get<List<int>>(
+  'https://merry99-musclecare-train-ai.hf.space/model',
+  options: Options(responseType: ResponseType.bytes),
+);
+
+if (response.statusCode == 200) {
+  final version = response.headers.value('X-Model-Version');
+  final filename = response.headers.value('X-Model-Filename') ?? 'model.tflite';
+  await File('/path/$filename').writeAsBytes(response.data!);
+} else {
+  final errorText = utf8.decode(response.data ?? []);
+  // 에러 처리
+}
+```
+- Space 환경 변수 `HF_E2E_MODEL_TOKEN`, `HF_E2E_MODEL_REPO_ID`가 올바르게 설정돼 있어야 `/model` 및 `/trigger`가 정상 동작합니다.
+
+
+## 모델 입력 사양 (Flutter 참고)
+
+- 입력 형상: `(batch_size, input_dim)`이며 기본 `input_dim = 10 (FEATURE_COLUMNS) + embedding_dim`.
+- `FEATURE_COLUMNS`: `rms_acc`, `rms_gyro`, `mean_freq_acc`, `mean_freq_gyro`, `entropy_acc`, `entropy_gyro`, `jerk_mean`, `jerk_std`, `stability_index`, `fatigue_prev`.
+- `user_emb`: 메타데이터의 `embedding_dim`과 동일한 길이. 부족하면 뒤를 `0.0f`로 패딩.
+- 메타데이터(`cnn_gru_fatigue_metadata.json`)의 `scaler.mean`, `scaler.scale`로 표준화한 뒤 모델에 전달.
+
+### Flutter에서 실행 순서
+- **메타데이터 로드**: JSON에서 `feature_columns`, `scaler.mean`, `scaler.scale`, `embedding_dim`, `input_dim`을 읽는다.
+- **특징 추출**: 측정 버튼을 눌러 얻은 윈도우에서 10개 피처 값을 계산한다.
+- **표준화**: `(value - mean) / scale`을 수행하되 `scale`이 0이면 0으로 대체.
+- **입력 벡터 구성**: `[정규화된 10개 피처, user_emb(패딩 포함)]`을 이어 붙여 `Float32List`로 만든다.
+- **TFLite 실행**: 입력을 `[1, input_dim]`으로 reshape 후 `interpreter.run(input, output)`을 호출한다.
+
+```dart
+final meta = await loadMetadata(); // JSON 파싱: scaler, embedding_dim 등
+final features = computeFeatureVector(); // 길이 10, float
+final userEmb = ensureEmbeddingLength(rawEmb, meta.embeddingDim); // 패딩
+
+final normalized = List<double>.generate(features.length, (i) {
+  final scale = meta.scalerScale[i] == 0 ? 1.0 : meta.scalerScale[i];
+  return (features[i] - meta.scalerMean[i]) / scale;
+});
+
+final inputVector = Float32List.fromList([
+  ...normalized,
+  ...userEmb.map((e) => e.toDouble()),
+]);
+
+final outputBuffer = Float32List(1);
+interpreter.run(inputVector.reshape([1, inputVector.length]), outputBuffer);
+final fatigueScore = outputBuffer[0];
+```
+
+### 주의
+- 최초 측정부터 바로 예측 가능하며, 더 이상 5개 윈도우 누적이 필요하지 않습니다.
+- `fatigue_prev`는 직전 측정의 피로도 지표로, 값이 없다면 `0` 또는 직전 예측치로 초기화해 주세요.
+- 피처 추출 로직과 임베딩 차원은 백엔드 학습 파이프라인과 동일해야 합니다.

requirements.txt

@@ -0,0 +1,22 @@
+# Python 3.10+ 환경을 가정합니다.
+typing_extensions>=4.8.0,<5.0.0
+numpy>=1.23.0,<1.27.0
+torch>=2.0.0
+transformers>=4.30.0
+datasets>=2.14.0
+pandas>=2.0.0
+scikit-learn>=1.3.0
+tqdm>=4.65.0
+schedule>=1.2.0
+huggingface-hub>=0.24.0
+python-dotenv>=1.0.0
+fastapi>=0.110.0
+uvicorn[standard]>=0.23.0
+
+# TFLite 변환용 패키지 (호환 버전)
+# PyTorch와 TensorFlow가 함께 설치될 때 충돌 방지를 위해 순서 중요
+onnx==1.15.0
+onnx-tf==1.10.0
+tensorflow==2.15.0
+protobuf<4.0.0
+tensorflow-probability>=0.23.0

run_local.sh

@@ -0,0 +1,39 @@
+#!/bin/bash
+# 로컬 실행 스크립트 (venv 없이)
+
+echo "🚀 MuscleCare Train AI - 로컬 실행"
+echo "=================================="
+
+# Python 3.10 확인
+PYTHON_CMD=""
+if command -v python3.10 &> /dev/null; then
+    PYTHON_CMD="python3.10"
+elif [ -f /usr/local/bin/python3.10 ]; then
+    PYTHON_CMD="/usr/local/bin/python3.10"
+else
+    echo "❌ Python 3.10이 필요합니다."
+    echo "   설치: brew install python@3.10"
+    exit 1
+fi
+
+echo "✅ Python 버전: $($PYTHON_CMD --version)"
+echo ""
+
+# 패키지 설치 확인
+echo "📦 필수 패키지 확인 중..."
+$PYTHON_CMD -c "import torch; import onnx; import tensorflow" 2>/dev/null
+if [ $? -ne 0 ]; then
+    echo "⚠️  일부 패키지가 설치되지 않았습니다."
+    echo "   설치: $PYTHON_CMD -m pip install --user -r requirements.txt"
+    echo ""
+    read -p "지금 설치하시겠습니까? [y/N]: " -n 1 -r
+    echo
+    if [[ $REPLY =~ ^[Yy]$ ]]; then
+        $PYTHON_CMD -m pip install --user -r requirements.txt
+    fi
+fi
+
+echo ""
+echo "▶️  자동 학습 스케줄러 실행 중..."
+$PYTHON_CMD start.py
+

start.py

@@ -0,0 +1,10 @@
+"""
+MuscleCare Train AI - 자동 학습 스케줄러 시작 스크립트
+매주 일요일 자정에 모델을 자동으로 학습합니다.
+"""
+
+from train_scheduler import main
+
+if __name__ == "__main__":
+    main()
+

train_e2e.py

@@ -0,0 +1,319 @@
+"""
+End-to-End 모델 학습 스크립트 (TensorFlow)
+단일 윈도우(센서 특징 + user_emb)를 입력으로 받아 피로도를 예측하는
+MLP 기반 회귀 모델을 학습하고 SavedModel/TFLite 형식으로 저장합니다.
+"""
+
+import os
+import json
+from typing import Dict, Iterable, Optional, Tuple, Union
+
+import numpy as np
+import pandas as pd
+import tensorflow as tf
+from sklearn.preprocessing import StandardScaler
+from tensorflow.keras.layers import BatchNormalization, Dense, Dropout, Input
+from tensorflow.keras.models import Model
+
+from load_dataset import load_musclecare_dataset
+
+
+FEATURE_COLUMNS = [
+    'rms_acc',
+    'rms_gyro',
+    'mean_freq_acc',
+    'mean_freq_gyro',
+    'entropy_acc',
+    'entropy_gyro',
+    'jerk_mean',
+    'jerk_std',
+    'stability_index',
+    'fatigue_prev',
+]
+
+DEFAULT_EPOCHS = 30
+DEFAULT_EMBED_DIM = 12
+DEFAULT_BATCH_SIZE = 64
+
+
+def parse_user_emb(emb: Union[str, Iterable[float], np.ndarray]) -> np.ndarray:
+    """사용자 임베딩을 numpy 배열로 변환"""
+    arr: Optional[np.ndarray] = None
+
+    if isinstance(emb, np.ndarray):
+        arr = emb.astype(np.float32)
+    elif isinstance(emb, str):
+        try:
+            arr = np.array(json.loads(emb), dtype=np.float32)
+        except (json.JSONDecodeError, TypeError):
+            arr = None
+    elif isinstance(emb, Iterable):
+        arr = np.array(list(emb), dtype=np.float32)
+
+    if arr is None or arr.ndim == 0:
+        arr = np.zeros(DEFAULT_EMBED_DIM, dtype=np.float32)
+
+    return arr
+
+
+def pad_embedding(embedding: np.ndarray, target_dim: int) -> np.ndarray:
+    """임베딩 길이를 target_dim에 맞춰 패딩"""
+    padded = np.zeros(target_dim, dtype=np.float32)
+    length = min(target_dim, embedding.size)
+    padded[:length] = embedding[:length]
+    return padded
+
+
+def dataset_split_to_dataframe(dataset_split) -> pd.DataFrame:
+    """HuggingFace Dataset split을 pandas DataFrame으로 변환"""
+    if hasattr(dataset_split, "to_pandas"):
+        return dataset_split.to_pandas()
+    return pd.DataFrame(dataset_split)
+
+
+def build_dataframe_from_source(
+    dataset_source,
+    exclude_sessions: Optional[Iterable[str]] = None
+) -> pd.DataFrame:
+    """데이터 소스를 단일 DataFrame으로 통합"""
+    frames = []
+    exclude_sessions = set(exclude_sessions or [])
+
+    if hasattr(dataset_source, "items"):
+        iterator = dataset_source.items()
+    else:
+        iterator = [("all", dataset_source)]
+
+    for split_name, split_dataset in iterator:
+        df_split = dataset_split_to_dataframe(split_dataset)
+        if df_split.empty:
+            continue
+
+        if exclude_sessions:
+            if 'session_id' not in df_split.columns:
+                raise KeyError("데이터셋에 'session_id' 컬럼이 없습니다.")
+            df_split = df_split[~df_split['session_id'].isin(exclude_sessions)]
+
+        if not df_split.empty:
+            frames.append(df_split)
+            print(f"  - {split_name}: {len(df_split)}개 샘플 (필터링 후)")
+
+    if not frames:
+        return pd.DataFrame()
+
+    return pd.concat(frames, ignore_index=True)
+
+
+def prepare_training_arrays(
+    df: pd.DataFrame,
+    feature_cols: Iterable[str]
+) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    """단일 윈도우 입력을 위한 학습 데이터를 생성"""
+    required_columns = set(feature_cols) | {'fatigue', 'user_emb'}
+    missing_columns = required_columns - set(df.columns)
+    if missing_columns:
+        raise KeyError(f"데이터셋에 누락된 컬럼이 있습니다: {sorted(missing_columns)}")
+
+    feature_values = (
+        df[list(feature_cols)]
+        .astype(np.float32)
+        .replace([np.inf, -np.inf], np.nan)
+        .fillna(0.0)
+    )
+
+    scaler = StandardScaler()
+    features_scaled = scaler.fit_transform(feature_values).astype(np.float32)
+
+    user_embeddings = np.stack([
+        emb.astype(np.float32) if isinstance(emb, np.ndarray) else np.zeros(DEFAULT_EMBED_DIM, dtype=np.float32)
+        for emb in df['user_emb']
+    ])
+
+    X = np.concatenate([features_scaled, user_embeddings], axis=1).astype(np.float32)
+    y = df['fatigue'].astype(np.float32).to_numpy()
+
+    return X, y, scaler.mean_.astype(np.float32), scaler.scale_.astype(np.float32)
+
+
+def build_dense_regression_model(
+    input_dim: int,
+    learning_rate: float = 0.001
+) -> Model:
+    """단일 윈도우 입력용 MLP 회귀 모델"""
+    inputs = Input(shape=(input_dim,), name="features")
+
+    x = Dense(128, activation='relu')(inputs)
+    x = BatchNormalization()(x)
+    x = Dropout(0.3)(x)
+
+    x = Dense(64, activation='relu')(x)
+    x = BatchNormalization()(x)
+    x = Dropout(0.2)(x)
+
+    outputs = Dense(1, activation='linear', name='fatigue')(x)
+
+    model = Model(inputs=inputs, outputs=outputs)
+    model.compile(
+        optimizer=tf.keras.optimizers.Adam(learning_rate=learning_rate),
+        loss='mse',
+        metrics=['mae']
+    )
+    return model
+
+
+def ensure_embeddings(df: pd.DataFrame) -> Tuple[pd.DataFrame, int]:
+    """user_emb 컬럼을 numpy 배열로 정규화하고 통일된 차원으로 패딩"""
+    if 'user_emb' not in df.columns:
+        raise KeyError("데이터셋에 'user_emb' 컬럼이 없습니다.")
+
+    df = df.copy()
+    df['user_emb'] = df['user_emb'].apply(parse_user_emb)
+
+    dims = [
+        emb.size for emb in df['user_emb']
+        if isinstance(emb, np.ndarray) and emb.size > 0
+    ]
+    target_dim = max(dims) if dims else DEFAULT_EMBED_DIM
+
+    df['user_emb'] = df['user_emb'].apply(lambda emb: pad_embedding(emb, target_dim))
+
+    return df, target_dim
+
+
+def main(
+    data_list: Optional[Iterable[Dict]] = None,
+    exclude_sessions: Optional[Iterable[str]] = None,
+    epochs: int = DEFAULT_EPOCHS
+) -> Optional[Dict[str, str]]:
+    """
+    메인 학습 함수
+    
+    Args:
+        data_list: 사용할 데이터 리스트 (None이면 전체 데이터 사용)
+        exclude_sessions: 제외할 session_id 집합 (중복 방지용)
+        epochs: 학습 에포크 수
+    """
+    print("=" * 80)
+    print("MuscleCare Train AI - TensorFlow Single-Window Training")
+    print("=" * 80)
+    
+    tf.keras.utils.set_random_seed(42)
+    
+    # 1️⃣ 데이터 로드
+    print("1️⃣ 데이터셋 로딩 중...")
+    if data_list is None:
+        dataset_source = load_musclecare_dataset()
+        df = build_dataframe_from_source(dataset_source, exclude_sessions)
+    else:
+        df = pd.DataFrame(data_list)
+        if exclude_sessions:
+            df = df[~df['session_id'].isin(set(exclude_sessions))]
+
+    if df.empty:
+        print("⚠️  학습 가능한 데이터가 없습니다. 학습을 종료합니다.")
+        print("=" * 80)
+        return None
+
+    print(f"✅ 데이터 로드 완료: {len(df)}개 행")
+
+    # 2️⃣ 사용자 임베딩 정규화
+    print("2️⃣ 사용자 임베딩 정규화 중...")
+    df, emb_dim = ensure_embeddings(df)
+    print(f"✅ 임베딩 차원: {emb_dim}")
+
+    # 3️⃣ 학습 데이터 생성
+    print("3️⃣ 학습 데이터 생성 중...")
+    X, y, scaler_mean, scaler_scale = prepare_training_arrays(df, FEATURE_COLUMNS)
+    if X.size == 0:
+        print("⚠️  학습할 입력 데이터가 없습니다. 학습을 종료합니다.")
+        print("=" * 80)
+        return None
+    num_samples, input_dim = X.shape
+    print(f"✅ 학습 데이터 생성 완료: {num_samples}개 샘플, 입력 차원 {input_dim}")
+
+    # 4️⃣ 모델 생성
+    print("4️⃣ 모델 생성 중...")
+    model = build_dense_regression_model(input_dim)
+    model.summary(print_fn=lambda x: print("   " + x))
+    print("✅ 모델 생성 완료")
+    
+    # 5️⃣ 모델 학습
+    print("5️⃣ 모델 학습 시작...")
+    callbacks = [
+        tf.keras.callbacks.EarlyStopping(patience=5, restore_best_weights=True),
+        tf.keras.callbacks.ReduceLROnPlateau(patience=3, factor=0.5),
+    ]
+    validation_split = 0.1 if num_samples >= 20 else 0.0
+    history = model.fit(
+        X,
+        y,
+        epochs=epochs,
+        batch_size=min(DEFAULT_BATCH_SIZE, num_samples),
+        shuffle=True,
+        validation_split=validation_split,
+        callbacks=callbacks,
+        verbose=1,
+    )
+    print("✅ 모델 학습 완료")
+
+    # 6️⃣ 모델 및 메타데이터 저장
+    print("6️⃣ 모델 저장 중...")
+    model_dir = './model'
+    os.makedirs(model_dir, exist_ok=True)
+
+    keras_model_path = os.path.join(model_dir, 'cnn_gru_fatigue.keras')
+    model.save(keras_model_path)
+
+    metadata = {
+        "feature_columns": list(FEATURE_COLUMNS),
+        "embedding_dim": emb_dim,
+        "input_dim": input_dim,
+        "epochs": epochs,
+        "num_samples": int(num_samples),
+        "scaler": {
+            "mean": scaler_mean.tolist(),
+            "scale": scaler_scale.tolist(),
+        },
+        "history": {
+            "loss": history.history.get('loss', []),
+            "mae": history.history.get('mae', []),
+            "val_loss": history.history.get('val_loss', []),
+            "val_mae": history.history.get('val_mae', []),
+        },
+    }
+
+    metadata_path = os.path.join(model_dir, 'cnn_gru_fatigue_metadata.json')
+    with open(metadata_path, 'w', encoding='utf-8') as f:
+        json.dump(metadata, f, ensure_ascii=False, indent=2)
+
+    print(f"✅ 모델 저장 완료: {keras_model_path}")
+    print(f"   메타데이터 저장: {metadata_path}")
+
+    # 7️⃣ TFLite 변환
+    print("7️⃣ TFLite 변환 중...")
+    converter = tf.lite.TFLiteConverter.from_keras_model(model)
+    converter.target_spec.supported_ops = [
+        tf.lite.OpsSet.TFLITE_BUILTINS,
+        tf.lite.OpsSet.SELECT_TF_OPS,
+    ]
+    converter._experimental_lower_tensor_list_ops = False
+    converter.optimizations = [tf.lite.Optimize.DEFAULT]
+    tflite_model = converter.convert()
+
+    tflite_model_path = os.path.join(model_dir, 'cnn_gru_fatigue.tflite')
+    with open(tflite_model_path, 'wb') as f:
+        f.write(tflite_model)
+
+    print(f"✅ TFLite 모델 저장 완료: {tflite_model_path}")
+    print("=" * 80)
+
+    return {
+        "keras": os.path.abspath(keras_model_path),
+        "tflite": os.path.abspath(tflite_model_path),
+        "metadata": os.path.abspath(metadata_path),
+    }
+
+
+if __name__ == "__main__":
+    main()
+

train_scheduler.py

@@ -0,0 +1,265 @@
+"""
+주 1회 자동 모델 학습 스케줄러
+매주 일요일 자정에 실행되어 모델을 자동으로 업데이트합니다.
+"""
+
+import schedule
+import time
+import os
+import json
+import shutil
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, Optional
+
+from huggingface_hub import HfApi, hf_hub_download
+try:
+    from huggingface_hub.utils import HfHubHTTPError
+except ImportError:  # fallback for older versions
+    HfHubHTTPError = Exception  # type: ignore
+
+from train_e2e import main as train_main
+from load_dataset import load_musclecare_dataset
+
+
+class TrainingScheduler:
+    """모델 학습 스케줄러 클래스"""
+    
+    def __init__(self, state_file: str = './model/training_state.json'):
+        """
+        Args:
+            state_file: 학습 상태를 저장할 파일 경로
+        """
+        self.state_file = state_file
+        self.state_dir = os.path.dirname(state_file)
+        os.makedirs(self.state_dir, exist_ok=True)
+        self._hf_token = os.getenv("HF_E2E_MODEL_TOKEN")
+        self._hf_repo_id = os.getenv("HF_E2E_MODEL_REPO_ID")
+        self._hf_state_filename = os.getenv("HF_E2E_MODEL_STATE_FILE", Path(state_file).name)
+
+        if not os.path.exists(self.state_file):
+            self._download_state_from_hub()
+        
+    def load_training_state(self):
+        """학습 상태 로드"""
+        if os.path.exists(self.state_file):
+            try:
+                with open(self.state_file, 'r', encoding='utf-8') as f:
+                    state = json.load(f)
+                return state
+            except Exception as e:
+                print(f"⚠️  학습 상태 로드 실패: {e}")
+                return self._get_default_state()
+        if self._download_state_from_hub():
+            return self.load_training_state()
+        return self._get_default_state()
+    
+    def save_training_state(self, state):
+        """학습 상태 저장"""
+        try:
+            with open(self.state_file, 'w', encoding='utf-8') as f:
+                json.dump(state, f, indent=2, ensure_ascii=False)
+            self._upload_state_to_hub()
+        except Exception as e:
+            print(f"⚠️  학습 상태 저장 실패: {e}")
+    
+    def _get_default_state(self):
+        """기본 학습 상태"""
+        return {
+            'processed_sessions': [],
+            'last_training_date': None,
+            'model_version': 0,
+            'total_data_count': 0
+        }
+
+    def reset_training_state(self):
+        """학습 상태 초기화"""
+        state = self._get_default_state()
+        self.save_training_state(state)
+        return state
+    
+    def get_new_data(self, processed_sessions):
+        """
+        새로운 데이터만 수집 (중복 방지)
+        
+        Args:
+            processed_sessions: 이미 처리된 session_id 집합
+            
+        Returns:
+            list: 새로운 데이터 리스트
+        """
+        print("📊 새로운 데이터 수집 중...")
+        dataset_dict = load_musclecare_dataset()
+        
+        new_data = []
+        new_sessions = set()
+        
+        for split_name in dataset_dict.keys():
+            for item in dataset_dict[split_name]:
+                session_id = item.get('session_id', '')
+                
+                # 중복 체크
+                if session_id not in processed_sessions:
+                    new_data.append(item)
+                    new_sessions.add(session_id)
+        
+        print(f"✅ 새로운 데이터: {len(new_data)}개 (새로운 세션: {len(new_sessions)}개)")
+        return new_data, new_sessions
+    
+    def train_incremental_model(self, new_data, processed_sessions):
+        """
+        증분 학습 수행 (전체 데이터로 재학습하되 중복 제외)
+        
+        Args:
+            new_data: 새로운 데이터 리스트
+            processed_sessions: 이미 처리된 session_id 집합
+        """
+        if not new_data:
+            print("⚠️  새로운 데이터가 없어 학습을 건너뜁니다.")
+            return None
+        
+        print(f"\n🔄 모델 학습 시작 (새로운 데이터: {len(new_data)}개 포함)...")
+        
+        # 전체 데이터를 가져오되, 중복된 세션은 제외
+        # train_e2e.py의 main 함수에 exclude_sessions 파라미터 전달
+        from train_e2e import main as train_main
+        training_outputs = train_main(data_list=None, exclude_sessions=processed_sessions)
+        
+        if isinstance(training_outputs, dict):
+            return (
+                training_outputs.get('tflite')
+                or training_outputs.get('keras')
+                or training_outputs.get('metadata')
+            )
+        
+        return training_outputs
+    
+    def run_scheduled_training(self) -> Dict[str, Optional[str]]:
+        """스케줄된 학습 실행"""
+        print("=" * 80)
+        print(f"🕛 자동 학습 시작 - {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        print("=" * 80)
+        
+        # 학습 상태 로드
+        state = self.load_training_state()
+        processed_sessions = set(state.get('processed_sessions', []))
+        
+        print(f"📋 현재 상태:")
+        print(f"   - 처리된 세션 수: {len(processed_sessions)}")
+        print(f"   - 마지막 학습일: {state.get('last_training_date', '없음')}")
+        print(f"   - 모델 버전: {state.get('model_version', 0)}")
+        
+        # 새로운 데이터 수집
+        new_data, new_sessions = self.get_new_data(processed_sessions)
+        
+        result: Dict[str, Optional[str]] = {
+            "status": "skipped",
+            "model_path": None,
+            "new_data_count": len(new_data),
+        }
+
+        if new_data:
+            # 증분 학습 수행 (전체 데이터로 재학습하되 중복 제외)
+            model_path = self.train_incremental_model(
+                new_data,
+                processed_sessions
+            )
+            
+            if model_path:
+                # 학습 상태 업데이트
+                processed_sessions.update(new_sessions)
+                state['processed_sessions'] = list(processed_sessions)
+                state['last_training_date'] = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+                new_version = state.get('model_version', 0) + 1
+                state['model_version'] = new_version
+                state['total_data_count'] = state.get('total_data_count', 0) + len(new_data)
+                
+                self.save_training_state(state)
+                
+                print("\n✅ 자동 학습 완료!")
+                print(f"   - 모델 경로: {model_path}")
+                print(f"   - 새로운 모델 버전: {state['model_version']}")
+                print(f"   - 총 처리된 데이터: {state['total_data_count']}개")
+                result.update({
+                    "status": "trained",
+                    "model_path": model_path,
+                    "new_data_count": len(new_data),
+                    "model_version": str(state['model_version']),
+                })
+
+        else:
+            print("\n⚠️  새로운 데이터가 없어 학습을 건너뜁니다.")
+        
+        print("=" * 80)
+        return result
+
+    def _get_hf_api(self) -> Optional[HfApi]:
+        if not self._hf_repo_id or not self._hf_token:
+            return None
+        return HfApi(token=self._hf_token)
+
+    def _download_state_from_hub(self) -> bool:
+        api = self._get_hf_api()
+        if api is None:
+            return False
+        try:
+            downloaded_path = hf_hub_download(
+                repo_id=self._hf_repo_id,
+                filename=self._hf_state_filename,
+                repo_type="model",
+                token=self._hf_token,
+                local_dir=self.state_dir,
+                local_dir_use_symlinks=False,
+            )
+            shutil.move(downloaded_path, self.state_file)
+            print(f"✅ Hugging Face Hub에서 학습 상태를 다운로드했습니다: {self._hf_state_filename}")
+            return True
+        except Exception as e:
+            status = getattr(getattr(e, "response", None), "status_code", None)
+            if status == 404:
+                print("ℹ️  Hugging Face Hub에 학습 상태 파일이 없어 새로 생성합니다.")
+            else:
+                print(f"⚠️  학습 상태 다운로드 중 오류가 발생했습니다: {e}")
+        return False
+
+    def _upload_state_to_hub(self) -> None:
+        api = self._get_hf_api()
+        if api is None:
+            return
+        try:
+            api.create_repo(repo_id=self._hf_repo_id, repo_type="model", private=False, exist_ok=True)
+            api.upload_file(
+                path_or_fileobj=self.state_file,
+                path_in_repo=self._hf_state_filename,
+                repo_id=self._hf_repo_id,
+                repo_type="model",
+                commit_message="Update training state",
+            )
+            print("✅ 학습 상태를 Hugging Face Hub에 업로드했습니다.")
+        except Exception as e:
+            print(f"⚠️  학습 상태 업로드 실패: {e}")
+
+
+def main():
+    """메인 함수"""
+    scheduler = TrainingScheduler()
+    
+    # 매주 일요일 자정에 실행
+    schedule.every().day.at("00:00").do(scheduler.run_scheduled_training)
+    
+    print("📅 자동 학습 스케줄러 시작")
+    print("   - 실행 시간: 매일 00:00")
+    print("   - 종료하려면 Ctrl+C를 누르세요\n")
+    
+    # 스케줄러 실행
+    try:
+        while True:
+            schedule.run_pending()
+            time.sleep(60)  # 1분마다 체크
+    except KeyboardInterrupt:
+        print("\n\n⏹️  스케줄러 종료")
+
+
+if __name__ == "__main__":
+    main()
+