🚀 Deploy SignView: 完整手語辨識系統部署到HuggingFace Spaces - 整合所有功能到單一app.py, 支援即時攝像頭辨識+影片上傳+Messenger Bot, PyTorch LSTM+Attention模型, MediaPipe特徵提取+OpenAI GPT-4o-mini, 支援4種手語: eat/fish/like/want

Dockerfile

@@ -1,32 +1,34 @@
-# 使用官方 Python 映像檔作為基礎
-FROM python:3.12.3-slim
+FROM python:3.10-slim
 
-# 設定工作目錄
 WORKDIR /app
 
-# 將 requirements.txt 複製到工作目錄中
+# 安裝系統依賴
+RUN apt-get update && apt-get install -y \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# 複製依賴檔案
 COPY requirements.txt .
 
-# 更新 pip 並安裝所需的套件
-# 我們需要 git 來安裝特定版本的套件 (如果有的話)
-# 以及 build-essential 來編譯某些相依套件
-RUN apt-get update && apt-get install -y git build-essential && \
-    pip install --no-cache-dir --upgrade pip && \
-    pip install --no-cache-dir -r requirements.txt
+# 安裝 Python 依賴
+RUN pip install --no-cache-dir -r requirements.txt
 
-# 將專案中的所有檔案複製到工作目錄中
+# 複製應用程式檔案
 COPY . .
 
-# 設定環境變數 (這些應該在 Hugging Face Space 的 secrets 中設定)
-# ENV VERIFY_TOKEN="your_verify_token"
-# ENV PAGE_ACCESS_TOKEN="your_page_access_token"
-# ENV OPENAI_API_KEY="your_openai_api_key"
+# 建立必要目錄
+RUN mkdir -p uploads data/models data/features/keypoints
+
+# 暴露端口
+EXPOSE 7860
 
-# 開放應用程式運行的埠口
-EXPOSE 8000
+# 設定環境變數
+ENV PYTHONUNBUFFERED=1
 
-# 使用 Gunicorn 啟動應用程式
-# --bind 0.0.0.0:8000 讓它可以從外部被存取
-# --workers 1  對於免費方案，一個 worker 通常是比較穩定的選擇
-# --timeout 120 增加超時時間，以應對可能的模型載入或長時間的請求
-CMD ["gunicorn", "--bind", "0.0.0.0:8000", "--workers", "1", "--timeout", "120", "app:app"] 
+# 啟動命令
+CMD ["python", "app.py"] 

Procfile

@@ -1 +0,0 @@
-web: gunicorn app:app 

README.md

@@ -1,24 +1,187 @@
 ---
-title: SignView
-emoji: 👋
+title: SignView - 手語辨識整合系統
+emoji: 🤟
 colorFrom: blue
-colorTo: indigo
+colorTo: green
 sdk: docker
-app_file: app.py
-secrets:
-  - MESSENGER_ACCESS_TOKEN
-  - MESSENGER_VERIFY_TOKEN
+app_port: 7860
+pinned: boolean
+duplicated_from: XiaoBai1221/SignView
 ---
 
-# SignView - 手語辨識機器人
+# 手語辨識整合系統 (Sign Language Recognition System)
 
-這是一個基於 Flask 的 Messenger 機器人，用於即時辨識手語影片。
+一個整合的手語辨識系統，支援即時攝像頭辨識、影片上傳處理和 Facebook Messenger Bot 功能。使用 PyTorch 深度學習模型、MediaPipe 特徵提取和 OpenAI GPT 生成自然語句。
 
-## Hugging Face Space 設定
+## 🚀 快速開始
 
-為了讓這個應用程式正常運作，您需要在 Space 的設定頁面中新增以下 Secrets（環境變數）：
+### HuggingFace Spaces 部署 (推薦)
 
-1.  `MESSENGER_ACCESS_TOKEN`: 你的 Facebook 粉絲專頁存取權杖。
-2.  `MESSENGER_VERIFY_TOKEN`: 你在設定 Webhook 時自訂的驗證權杖。
+1. **Fork 此專案到你的 HuggingFace Spaces**
+2. **設定環境變數**：
+   ```
+   OPENAI_API_KEY=你的OpenAI_API金鑰
+   VERIFY_TOKEN=你的Messenger驗證Token
+   PAGE_ACCESS_TOKEN=你的Facebook頁面存取Token
+   ```
+3. **自動部署** - HuggingFace 會自動建置和部署
 
-設定完成後，Hugging Face 會自動根據 `Dockerfile` 建置並啟動應用程式。 
+### 本地開發
+
+```bash
+# 1. 安裝依賴
+pip install -r requirements.txt
+
+# 2. 設定環境變數
+export OPENAI_API_KEY="你的OpenAI_API金鑰"
+export VERIFY_TOKEN="你的Messenger驗證Token" 
+export PAGE_ACCESS_TOKEN="你的Facebook頁面存取Token"
+
+# 3. 啟動應用
+python3 app.py
+```
+
+## 📁 專案結構
+
+```
+Sign-bot/
+├── app.py                    # 🎯 主應用程式 (整合所有功能)
+├── app_config.py            # ⚙️ 配置管理
+├── requirements.txt         # 📦 Python依賴套件
+├── Dockerfile              # 🐳 Docker容器配置
+├── README.md               # 📖 專案文檔
+├── final_review_gate.py    # 🔍 測試腳本
+├── data/                   # 📊 資料目錄
+│   ├── models/            # 🤖 訓練好的模型檔案
+│   │   └── sign_language_model.pth
+│   ├── labels.csv         # 🏷️ 標籤映射檔案
+│   └── features/          # 🎬 訓練特徵資料
+│       ├── keypoints/     # ✋ 關鍵點特徵檔案
+│       └── optical_flow/  # 🌊 光流特徵檔案
+├── templates/             # 🌐 網頁範本
+│   └── index.html        # 首頁範本
+└── uploads/              # 📁 暫時檔案上傳目錄
+```
+
+## ✨ 功能特色
+
+### 🎯 **整合設計**
+- **統一入口**: 所有功能整合在 `app.py` 單一檔案
+- **環境適配**: 自動檢測本地/雲端環境並調整功能
+- **模組化**: 清晰的類別結構，易於維護
+
+### 🤖 **AI 手語辨識**
+- **深度學習模型**: PyTorch LSTM + Attention 機制
+- **特徵提取**: MediaPipe 提取手部、姿態關鍵點
+- **自然語句生成**: OpenAI GPT-4o-mini 生成流暢句子
+- **支援手語**: 目前支援 eat, fish, like, want 四個手語
+
+### 🌐 **多平台支援**
+- **Web 介面**: 即時攝像頭辨識 + 影片上傳處理
+- **Messenger Bot**: Facebook 整合，自動處理使用者影片
+- **RESTful API**: 提供第三方整合接口
+- **WebSocket**: 即時雙向通訊
+
+### 📱 **使用方式**
+
+#### Web 介面 (本地環境)
+1. 造訪 `http://localhost:7860`
+2. 點擊「開始辨識」使用攝像頭
+3. 或上傳 MP4 影片檔案
+
+#### Messenger Bot
+1. 找到你的 Facebook 頁面
+2. 發送手語影片
+3. 系統自動辨識並回傳結果
+
+#### API 呼叫
+```bash
+# 上傳影片進行辨識
+curl -X POST http://localhost:7860/process_video \
+  -F "video=@your_video.mp4" \
+  -F "sender_id=test_user"
+```
+
+## 🔧 技術架構
+
+### 核心類別
+- **FeatureExtractor**: MediaPipe 特徵提取器
+- **SignLanguageModel**: PyTorch LSTM 神經網絡
+- **VideoSignLanguageRecognizer**: 影片手語辨識器
+- **SignLanguageRecognizer**: 即時手語辨識器
+
+### 技術棧
+- **後端**: Flask + SocketIO
+- **AI框架**: PyTorch + MediaPipe
+- **自然語言**: OpenAI GPT-4o-mini
+- **前端**: HTML5 + WebSocket
+- **部署**: HuggingFace Spaces + Docker
+
+## 🌍 環境變數
+
+| 變數名稱 | 說明 | 必須 |
+|---------|------|------|
+| `OPENAI_API_KEY` | OpenAI API 金鑰 | ✅ |
+| `VERIFY_TOKEN` | Messenger 驗證 Token | Messenger功能需要 |
+| `PAGE_ACCESS_TOKEN` | Facebook 頁面存取 Token | Messenger功能需要 |
+| `SPACE_ID` | HuggingFace Space ID | 自動設定 |
+| `PORT` | 服務埠號 | 預設 7860 |
+
+## 🎮 API 端點
+
+### Web 路由
+- `GET /` - 主頁面
+- `GET /health` - 健康檢查
+- `POST /process_video` - 影片處理
+
+### Messenger 整合
+- `GET /webhook` - Webhook ��證
+- `POST /webhook` - 訊息處理
+
+### WebSocket 事件
+- `start_stream` - 開始視頻流
+- `stop_stream` - 停止視頻流
+
+## 🚀 部署指南
+
+### HuggingFace Spaces
+1. 建立新的 Space (Gradio/Docker)
+2. 上傳所有檔案
+3. 設定環境變數
+4. 自動部署完成
+
+### Docker 部署
+```bash
+# 建置映像
+docker build -t sign-language-recognition .
+
+# 執行容器
+docker run -p 7860:7860 \
+  -e OPENAI_API_KEY="你的金鑰" \
+  sign-language-recognition
+```
+
+## 🎯 使用限制
+
+- **模型準確度**: 目前為測試版本，準確度可能有限
+- **支援手語**: 僅支援 4 個基礎手語詞彙
+- **攝像頭功能**: 雲端環境不支援，請使用影片上傳
+- **檔案大小**: 影片檔案限制 100MB
+
+## 🔄 未來規劃
+
+- [ ] 增加更多手語詞彙支援
+- [ ] 提升模型準確度
+- [ ] 支援手語語法結構
+- [ ] 加入使用者自訓練功能
+- [ ] 支援多語言介面
+
+## 📞 技術支援
+
+如有問題請透過以下方式聯絡：
+- GitHub Issues
+- 或直接在 HuggingFace Space 留言
+
+---
+
+> **🎉 這是一個整合型手語辨識系統，將所有功能統一整合在 `app.py` 中，提供最佳的使用體驗和部署便利性！** 

app.py

@@ -1,37 +1,750 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
 import os
 import json
 import requests
-from flask import Flask, request, jsonify
-from datetime import datetime
+import cv2
+import numpy as np
+import pandas as pd
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import base64
 import threading
 import time
+import mediapipe as mp
+import collections
+from flask import Flask, request, jsonify, render_template, Response
+from werkzeug.utils import secure_filename
+from datetime import datetime
+from flask_socketio import SocketIO, emit
+from openai import OpenAI
 
-# 匯入我們的手語處理器
-from sign_language_processor import VideoSignLanguageRecognizer
+# 環境變數設定
+os.environ.setdefault("OPENAI_API_KEY", "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")
 
+# 環境檢測
+IS_HUGGINGFACE = os.environ.get('SPACE_ID') is not None
+IS_LOCAL_DEV = not IS_HUGGINGFACE
+
+# Flask 應用初始化
 app = Flask(__name__)
+app.config['SECRET_KEY'] = 'sign_language_secret_key'
+app.config['MAX_CONTENT_LENGTH'] = 100 * 1024 * 1024  # 100MB max file size
+socketio = SocketIO(app, cors_allowed_origins="*", async_mode='threading')
 
-# 從環境變數取得設定
+# Messenger Bot 設定
 VERIFY_TOKEN = os.environ.get('VERIFY_TOKEN', 'your_verify_token')
 PAGE_ACCESS_TOKEN = os.environ.get('PAGE_ACCESS_TOKEN', 'your_page_access_token')
 FACEBOOK_API_URL = 'https://graph.facebook.com/v18.0/me/messages'
 
-# --- Initializations ---
-# 初始化手語辨識器
-# 注意：你需要確保 'models/sign_language_model.pth' 和 'labels.csv' 存在
-try:
-    recognizer = VideoSignLanguageRecognizer(
-        model_path='models/sign_language_model.pth'
+# 路徑設定 - 適應不同環境
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DATA_DIR = os.path.join(BASE_DIR, 'data')
+MODEL_PATH = os.path.join(DATA_DIR, 'models', 'sign_language_model.pth')
+LABELS_PATH = os.path.join(DATA_DIR, 'labels.csv')
+UPLOAD_FOLDER = os.path.join(BASE_DIR, 'uploads')
+
+# 建立必要資料夾
+for folder in [UPLOAD_FOLDER, os.path.join(DATA_DIR, 'models'), os.path.join(DATA_DIR, 'features', 'keypoints')]:
+    os.makedirs(folder, exist_ok=True)
+
+# 全域變數
+camera = None
+recognizer = None
+is_running = False
+frame_lock = threading.Lock()
+current_frame = None
+
+print(f"🌍 運行環境: {'HuggingFace Spaces' if IS_HUGGINGFACE else '本地開發'}")
+print(f"📁 基礎目錄: {BASE_DIR}")
+print(f"🤖 模型路徑: {MODEL_PATH}")
+print(f"📊 標籤路徑: {LABELS_PATH}")
+
+#--------------------
+# AI 模型類別
+#--------------------
+class FeatureExtractor:
+    def __init__(self):
+        # 初始化MediaPipe模型
+        self.mp_holistic = mp.solutions.holistic
+        self.mp_drawing = mp.solutions.drawing_utils
+        self.mp_drawing_styles = mp.solutions.drawing_styles
+        
+    def extract_pose_keypoints(self, frame, holistic_results):
+        """提取骨架關鍵點"""
+        keypoints = []
+        
+        # 提取手部關鍵點 (如果檢測到)
+        if holistic_results.left_hand_landmarks:
+            for landmark in holistic_results.left_hand_landmarks.landmark:
+                keypoints.extend([landmark.x, landmark.y, landmark.z])
+        else:
+            # 如果沒有檢測到手，填充0
+            keypoints.extend([0] * (21 * 3))
+            
+        if holistic_results.right_hand_landmarks:
+            for landmark in holistic_results.right_hand_landmarks.landmark:
+                keypoints.extend([landmark.x, landmark.y, landmark.z])
+        else:
+            keypoints.extend([0] * (21 * 3))
+        
+        # 提取姿勢關鍵點
+        if holistic_results.pose_landmarks:
+            for landmark in holistic_results.pose_landmarks.landmark:
+                keypoints.extend([landmark.x, landmark.y, landmark.z])
+        else:
+            keypoints.extend([0] * (33 * 3))
+            
+        return np.array(keypoints)
+
+class SignLanguageModel(nn.Module):
+    """
+    手語辨識模型，使用雙向LSTM和注意力機制，加入批量標準化和殘差連接
+    """
+    def __init__(self, input_dim, hidden_dim, num_layers, num_classes, dropout=0.5):
+        super(SignLanguageModel, self).__init__()
+        self.hidden_dim = hidden_dim
+        self.num_layers = num_layers
+        self.num_classes = num_classes
+        
+        # 特徵投影層，將輸入映射到統一維度
+        self.feature_projection = nn.Sequential(
+            nn.Linear(input_dim, hidden_dim),
+            nn.BatchNorm1d(hidden_dim),
+            nn.ReLU(),
+            nn.Dropout(dropout/2)  # 較輕的dropout
+        )
+        
+        # 雙向LSTM層
+        self.lstm = nn.LSTM(
+            input_size=hidden_dim,
+            hidden_size=hidden_dim,
+            num_layers=num_layers,
+            batch_first=True,
+            dropout=dropout if num_layers > 1 else 0,
+            bidirectional=True
+        )
+        
+        # 批量標準化層（用於規範化LSTM輸出）
+        self.lstm_bn = nn.BatchNorm1d(hidden_dim * 2)
+        
+        # 注意力機制
+        self.attention = nn.Sequential(
+            nn.Linear(hidden_dim * 2, hidden_dim),
+            nn.Tanh(),
+            nn.Linear(hidden_dim, 1),
+            nn.Softmax(dim=1)
+        )
+        
+        # 分類器
+        self.classifier = nn.Sequential(
+            nn.Linear(hidden_dim * 2, hidden_dim),
+            nn.BatchNorm1d(hidden_dim),
+            nn.ReLU(),
+            nn.Dropout(dropout),
+            nn.Linear(hidden_dim, hidden_dim // 2),
+            nn.ReLU(),
+            nn.Dropout(dropout/2),
+            nn.Linear(hidden_dim // 2, num_classes)
+        )
+        
+        # L2正則化
+        self.l2_reg_alpha = 0.001
+        
+        # 初始化權重
+        self._init_weights()
+    
+    def _init_weights(self):
+        """初始化模型權重"""
+        for m in self.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.xavier_uniform_(m.weight)
+                if m.bias is not None:
+                    nn.init.zeros_(m.bias)
+            elif isinstance(m, nn.LSTM):
+                for name, param in m.named_parameters():
+                    if 'weight' in name:
+                        nn.init.orthogonal_(param)  # 正交初始化對RNN很有效
+                    elif 'bias' in name:
+                        nn.init.zeros_(param)
+    
+    def forward(self, x):
+        """前向傳播"""
+        # x的形狀: [batch_size, seq_len, feature_dim]
+        batch_size, seq_len, _ = x.size()
+        
+        # 特徵投影 - 需要調整維度以適應BatchNorm1d
+        x_reshaped = x.reshape(-1, x.size(-1))  # [batch_size*seq_len, feature_dim]
+        x_projected = self.feature_projection[0](x_reshaped)  # Linear層
+        x_projected = x_projected.reshape(batch_size, seq_len, -1)  # 恢復形狀 [batch_size, seq_len, hidden_dim]
+        x_projected = x_projected.transpose(1, 2)  # [batch_size, hidden_dim, seq_len] 用於BatchNorm
+        x_projected = self.feature_projection[1](x_projected)  # BatchNorm層
+        x_projected = x_projected.transpose(1, 2)  # 恢復形狀 [batch_size, seq_len, hidden_dim]
+        x_projected = self.feature_projection[2](x_projected)  # ReLU
+        x_projected = self.feature_projection[3](x_projected)  # Dropout
+        
+        # 保存輸入特徵，用於殘差連接
+        x_residual = x_projected
+        
+        # LSTM處理
+        lstm_out, _ = self.lstm(x_projected)
+        # lstm_out的形狀: [batch_size, seq_len, hidden_dim*2]
+        
+        # 對LSTM輸出應用BatchNorm
+        lstm_out_bn = lstm_out.transpose(1, 2)  # [batch_size, hidden_dim*2, seq_len]
+        lstm_out_bn = self.lstm_bn(lstm_out_bn)
+        lstm_out = lstm_out_bn.transpose(1, 2)  # [batch_size, seq_len, hidden_dim*2]
+        
+        # 注意力權重計算
+        attention_weights = self.attention(lstm_out)
+        # attention_weights的形狀: [batch_size, seq_len, 1]
+        
+        # 應用注意力機制
+        context = torch.bmm(lstm_out.transpose(1, 2), attention_weights)
+        # context的形狀: [batch_size, hidden_dim*2, 1]
+        context = context.squeeze(-1)
+        
+        # 最終分類
+        output = self.classifier(context)
+        # output的形狀: [batch_size, num_classes]
+        
+        return output 
+
+#--------------------
+# 手語辨識器類別
+#--------------------
+class VideoSignLanguageRecognizer:
+    """影片手語辨識器 - 專門處理影片檔案"""
+    def __init__(self, model_path, threshold=0.7):
+        self.model_path = model_path
+        self.threshold = threshold
+        
+        # 初始化特徵提取器
+        self.feature_extractor = FeatureExtractor()
+        
+        # 加載標籤映射
+        self.label_map = self._load_label_mapping()
+        
+        # 加載模型
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model = self._load_model()
+        
+        # GPT整合
+        try:
+            self.openai_client = OpenAI()
+        except Exception as e:
+            print(f"初始化OpenAI客户端出錯: {e}")
+            self.openai_client = None
+        
+        print(f"影片辨識器初始化完成！使用設備: {self.device}")
+    
+    def _load_label_mapping(self):
+        """加載標籤映射"""
+        label_map = {}
+        
+        # 嘗試從 labels.csv 讀取
+        labels_file = LABELS_PATH
+        print(f"🔍 嘗試載入標籤檔案: {labels_file}")
+        print(f"📂 當前工作目錄: {os.getcwd()}")
+        
+        if os.path.exists(labels_file):
+            try:
+                df = pd.read_csv(labels_file)
+                print(f"📄 標籤檔案內容:")
+                print(df)
+                
+                for _, row in df.iterrows():
+                    label_map[int(row['index'])] = row['label']
+                print(f"✅ 從 {labels_file} 載入了 {len(label_map)} 個類別標籤")
+                print(f"📊 標籤映射: {label_map}")
+            except Exception as e:
+                print(f"❌ 讀取 labels.csv 出錯: {e}")
+                # 使用默認映射
+                label_map = {0: "eat", 1: "fish", 2: "like", 3: "want"}
+        else:
+            print(f"❌ 標籤檔案不存在: {labels_file}")
+        
+        if not label_map:
+            # 使用默認映射
+            label_map = {0: "eat", 1: "fish", 2: "like", 3: "want"}
+            print(f"⚠️ 使用預設標籤映射: {label_map}")
+        
+        return label_map
+    
+    def _load_model(self):
+        """加載訓練好的模型"""
+        input_dim = 225  # (21+21+33) * 3 = 225
+        
+        model = SignLanguageModel(
+            input_dim=input_dim,
+            hidden_dim=96,
+            num_layers=2,
+            num_classes=len(self.label_map),
+            dropout=0.5
+        )
+        
+        # 檢查模型檔案是否存在
+        if not os.path.exists(self.model_path):
+            print(f"⚠️ 警告：模型檔案不存在 {self.model_path}")
+            print("🔧 將使用隨機初始化的模型（僅供測試）")
+            # 隨機初始化權重用於測試
+            model.to(self.device)
+            model.eval()
+            return model
+        
+        try:
+            # 載入權重
+            model.load_state_dict(torch.load(self.model_path, map_location=self.device))
+            model.to(self.device)
+            model.eval()
+            print(f"✅ 模型載入成功：{self.model_path}")
+        except Exception as e:
+            print(f"❌ 模型載入失敗：{e}")
+            print("🔧 使用隨機初始化的模型")
+            model.to(self.device)
+            model.eval()
+        
+        return model
+    
+    def process_video(self, video_path):
+        """處理整個影片檔案"""
+        print(f"🎬 開始處理影片：{video_path}")
+        
+        # 開啟影片
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            print(f"❌ 無法開啟影片檔：{video_path}")
+            return None, 0
+        
+        # 提取特徵序列
+        keypoints_sequence = []
+        frame_count = 0
+        
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+            
+            # 跳幀處理
+            if frame_count % 5 == 0:  # 每5幀處理一次
+                keypoints, _ = self._extract_features(frame)
+                if keypoints is not None:
+                    keypoints_sequence.append(keypoints)
+                    
+            frame_count += 1
+            
+            # 限制處理幀數
+            if len(keypoints_sequence) >= 60:
+                break
+        
+        cap.release()
+        
+        if len(keypoints_sequence) < 3:
+            print(f"❌ 有效幀數不足，無法進行辨識")
+            return None, 0
+        
+        # 進行預測
+        prediction, confidence, word_sequence = self._predict_from_sequence(keypoints_sequence)
+        
+        # 使用GPT生成完整句子
+        generated_sentence = self._generate_sentence_with_gpt(word_sequence)
+        
+        print(f"🎯 辨識結果：{generated_sentence}")
+        print(f"📈 信心度：{confidence:.2f}")
+        
+        return generated_sentence, confidence
+
+    def _extract_features(self, frame):
+        """從單一幀提取手部和姿勢特徵"""
+        with self.feature_extractor.mp_holistic.Holistic(
+            static_image_mode=False,
+            model_complexity=1,
+            smooth_landmarks=True,
+            enable_segmentation=False,
+            min_detection_confidence=0.1,
+            min_tracking_confidence=0.1
+        ) as holistic:
+            # 轉為RGB
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            
+            # 處理圖像
+            results = holistic.process(frame_rgb)
+            
+            # 檢查是否有手部被檢測到
+            hands_detected = (results.left_hand_landmarks is not None or 
+                             results.right_hand_landmarks is not None)
+            
+            try:
+                keypoints = self.feature_extractor.extract_pose_keypoints(frame, results)
+                return keypoints, hands_detected
+            except Exception as e:
+                return None, hands_detected
+
+    def _predict_from_sequence(self, keypoints_sequence):
+        """從關鍵點序列進行預測"""
+        # 簡化版預測 - 直接使用整個序列
+        sequence_tensor = torch.FloatTensor(keypoints_sequence).unsqueeze(0).to(self.device)
+        
+        with torch.no_grad():
+            outputs = self.model(sequence_tensor)
+            probabilities = torch.nn.functional.softmax(outputs, dim=1)
+            max_prob, predicted_class = torch.max(probabilities, 1)
+            
+            predicted_class = predicted_class.item()
+            confidence = max_prob.item()
+            
+        if confidence >= self.threshold:
+            predicted_word = self.label_map.get(predicted_class, f"類別{predicted_class}")
+            word_sequence = [predicted_word]
+        else:
+            word_sequence = []
+            
+        return predicted_class, confidence, word_sequence
+
+    def _generate_sentence_with_gpt(self, word_sequence):
+        """使用GPT根據單詞序列生成一個完整句子"""
+        if not word_sequence:
+            return "無法辨識手語內容"
+            
+        if not self.openai_client:
+            return " ".join(word_sequence)
+            
+        try:
+            prompt = f"我使用手語表達了以下單詞序列: {', '.join(word_sequence)}。請將這些單詞組織成一個有意義、通順的完整句子。"
+            
+            response = self.openai_client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[
+                    {"role": "system", "content": "你是一個專業的手語翻譯助手。"},
+                    {"role": "user", "content": prompt}
+                ],
+                max_tokens=100
+            )
+            
+            return response.choices[0].message.content.strip()
+            
+        except Exception as e:
+            print(f"調用GPT API時出錯: {e}")
+            return " ".join(word_sequence)
+
+class SignLanguageRecognizer:
+    """即時手語辨識器 - 用於攝像頭流"""
+    def __init__(self, model_path, frame_buffer_size=30, prediction_interval=15, threshold=0.7):
+        self.model_path = model_path
+        self.threshold = threshold
+        self.max_buffer_size = frame_buffer_size
+        self.prediction_interval = prediction_interval
+        
+        # 初始化特徵提取器
+        self.feature_extractor = FeatureExtractor()
+        
+        # 加載標籤映射
+        self.label_map = self._load_label_mapping()
+        
+        # 加載模型
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model = self._load_model()
+        
+        # 緩衝區和狀態
+        self.keypoints_buffer = collections.deque(maxlen=frame_buffer_size)
+        self.frame_count = 0
+        self.current_prediction = None
+        self.prediction_probabilities = None
+        
+        # 手部存在檢測
+        self.hand_present = False
+        self.hand_absent_frames = 0
+        self.hand_absent_threshold = 30
+        
+        # 單詞序列
+        self.word_sequence = []
+        self.last_added_word = None
+        self.word_cooldown = 0
+        
+        # 生成的句子
+        self.generated_sentence = ""
+        self.display_sentence_time = 0
+        
+        # GPT整合
+        try:
+            self.openai_client = OpenAI()
+        except Exception as e:
+            print(f"初始化OpenAI客户端出錯: {e}")
+            self.openai_client = None
+        
+        print(f"即時辨識器初始化完成！使用設備: {self.device}")
+
+    def _load_label_mapping(self):
+        """加載標籤映射"""
+        label_map = {}
+        # 嘗試從特徵目錄推斷類別標籤
+        features_dir = os.path.join(DATA_DIR, 'features', 'keypoints')
+        if os.path.exists(features_dir):
+            unique_labels = set()
+            for file_name in os.listdir(features_dir):
+                if file_name.endswith('_keypoints.npy'):
+                    parts = file_name.split('_')
+                    if len(parts) >= 2:
+                        label = parts[0]
+                        if label not in unique_labels and not (label.startswith("aug") or "aug_" in label):
+                            unique_labels.add(label)
+            
+            if unique_labels:
+                label_map = {i: label for i, label in enumerate(sorted(unique_labels))}
+                print(f"從特徵目錄推斷了 {len(label_map)} 個類別標籤")
+            else:
+                label_map = {0: "eat", 1: "fish", 2: "like", 3: "want"}
+        else:
+            label_map = {0: "eat", 1: "fish", 2: "like", 3: "want"}
+        
+        return label_map
+
+    def _load_model(self):
+        """加載訓練好的模型"""
+        input_dim = 225
+        
+        model = SignLanguageModel(
+            input_dim=input_dim,
+            hidden_dim=96,
+            num_layers=2,
+            num_classes=len(self.label_map),
+            dropout=0.5
+        )
+        
+        # 檢查模型檔案是否存在
+        if not os.path.exists(self.model_path):
+            print(f"⚠️ 警告：模型檔案不存在 {self.model_path}")
+            print("🔧 將使用隨機初始化的模型（僅供測試）")
+            model.to(self.device)
+            model.eval()
+            return model
+        
+        try:
+            model.load_state_dict(torch.load(self.model_path, map_location=self.device))
+            model.to(self.device)
+            model.eval()
+            print(f"✅ 即時辨識模型載入成功：{self.model_path}")
+        except Exception as e:
+            print(f"❌ 即時辨識模型載入失敗：{e}")
+            print("🔧 使用隨機初始化的模型")
+            model.to(self.device)
+            model.eval()
+        
+        return model
+
+    def process_frame(self, frame):
+        """處理單個視頻幀"""
+        # 提取特徵和檢測手部
+        keypoint_features, hands_detected = self._extract_features(frame)
+        
+        # 更新手部存在狀態
+        self._update_hand_presence(hands_detected)
+        
+        # 僅當成功提取特徵時才繼續
+        if keypoint_features is not None:
+            self.keypoints_buffer.append(keypoint_features)
+        
+        # 定期進行預測
+        if self.hand_present and self.frame_count % self.prediction_interval == 0 and len(self.keypoints_buffer) > 5:
+            self._make_prediction()
+            self._update_word_sequence()
+        
+        # 手部離開時生成句子
+        if self.hand_present == False and self.hand_absent_frames == self.hand_absent_threshold and self.word_sequence:
+            self._generate_sentence_with_gpt()
+        
+        self.frame_count += 1
+        
+        if self.word_cooldown > 0:
+            self.word_cooldown -= 1
+        
+        # 回傳狀態
+        status = {
+            "hand_present": self.hand_present,
+            "frame_count": self.frame_count,
+            "current_prediction": None,
+            "word_sequence": self.word_sequence.copy(),
+            "generated_sentence": self.generated_sentence,
+            "display_sentence": (time.time() - self.display_sentence_time < 10)
+        }
+        
+        if self.current_prediction is not None:
+            if self.current_prediction == -1:
+                status["current_prediction"] = {"label": "未知", "confidence": 0}
+            else:
+                label = self.label_map.get(self.current_prediction, f"類別{self.current_prediction}")
+                confidence = float(self.prediction_probabilities[self.current_prediction]) if self.prediction_probabilities is not None else 0
+                status["current_prediction"] = {"label": label, "confidence": confidence}
+                
+                if self.prediction_probabilities is not None:
+                    status["probabilities"] = []
+                    sorted_indices = np.argsort(self.prediction_probabilities)[::-1][:4]
+                    for idx in sorted_indices:
+                        prob = float(self.prediction_probabilities[idx])
+                        class_label = self.label_map.get(idx, f"類別{idx}")
+                        status["probabilities"].append({"label": class_label, "probability": prob})
+        
+        return status
+
+    def _update_hand_presence(self, hands_detected):
+        """更新手部存在狀態"""
+        if hands_detected:
+            self.hand_present = True
+            self.hand_absent_frames = 0
+        else:
+            self.hand_absent_frames += 1
+            if self.hand_absent_frames >= self.hand_absent_threshold:
+                if self.hand_present:
+                    self.hand_present = False
+
+    def _update_word_sequence(self):
+        """根據當前預測更新單詞序列"""
+        if self.current_prediction is not None and self.current_prediction >= 0:
+            word = self.label_map.get(self.current_prediction, f"類別{self.current_prediction}")
+            
+            if word != self.last_added_word or self.word_cooldown == 0:
+                self.word_sequence.append(word)
+                self.last_added_word = word
+                self.word_cooldown = 20
+
+    def _generate_sentence_with_gpt(self):
+        """使用GPT根據單詞序列生成一個完整句子"""
+        if not self.word_sequence:
+            return
+            
+        if not self.openai_client:
+            self.generated_sentence = " ".join(self.word_sequence)
+            self.display_sentence_time = time.time()
+            print(f"生成句子: {self.generated_sentence}")
+            self.word_sequence = []
+            return
+            
+        try:
+            prompt = f"我使用手語表達了以下單詞序列: {', '.join(self.word_sequence)}。請將這些單詞組織成一個有意義、通順的完整句子。"
+            
+            response = self.openai_client.chat.completions.create(
+                model="gpt-4o-mini",
+                messages=[
+                    {"role": "system", "content": "你是一個專業的手語翻譯助手。"},
+                    {"role": "user", "content": prompt}
+                ],
+                max_tokens=100
+            )
+            
+            self.generated_sentence = response.choices[0].message.content.strip()
+            self.display_sentence_time = time.time()
+            print(f"GPT生成句子: {self.generated_sentence}")
+            
+        except Exception as e:
+            print(f"調用GPT API時出錯: {e}")
+            self.generated_sentence = " ".join(self.word_sequence)
+            self.display_sentence_time = time.time()
+            
+        self.word_sequence = []
+
+    def _extract_features(self, frame):
+        """從單一幀提取手部和姿勢特徵"""
+        with self.feature_extractor.mp_holistic.Holistic(
+            static_image_mode=False,
+            model_complexity=1,
+            smooth_landmarks=True,
+            enable_segmentation=False,
+            min_detection_confidence=0.1,
+            min_tracking_confidence=0.1
+        ) as holistic:
+            frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+            results = holistic.process(frame_rgb)
+            
+            hands_detected = (results.left_hand_landmarks is not None or 
+                             results.right_hand_landmarks is not None)
+            
+            try:
+                keypoints = self.feature_extractor.extract_pose_keypoints(frame, results)
+                return keypoints, hands_detected
+            except Exception as e:
+                return None, hands_detected
+
+    def _make_prediction(self):
+        """使用緩衝區中的特徵進行預測"""
+        if len(self.keypoints_buffer) < 2:
+            return
+            
+        keypoints_array = np.array(list(self.keypoints_buffer))
+        keypoints_tensor = torch.FloatTensor(keypoints_array).unsqueeze(0).to(self.device)
+        
+        with torch.no_grad():
+            outputs = self.model(keypoints_tensor)
+            probabilities = torch.nn.functional.softmax(outputs, dim=1)
+            
+            max_prob, predicted_class = torch.max(probabilities, 1)
+            predicted_class = predicted_class.item()
+            max_prob = max_prob.item()
+            
+            probs = probabilities[0].cpu().numpy()
+        
+        if max_prob >= self.threshold:
+            self.current_prediction = predicted_class
+            self.prediction_probabilities = probs
+        else:
+            self.current_prediction = -1
+            self.prediction_probabilities = probs
+
+def initialize_recognizer():
+    global recognizer
+    
+    model_path = MODEL_PATH
+    
+    recognizer = SignLanguageRecognizer(
+        model_path=model_path,
+        frame_buffer_size=30,
+        prediction_interval=10,
+        threshold=0.6
     )
-    print("✅ 手語辨識模型載入成功")
-except Exception as e:
-    recognizer = None
-    print(f"❌ 載入模型失敗: {e}")
-    print("👉 請確保 'models/sign_language_model.pth' 和 'labels.csv' 檔案存在於專案根目錄")
 
+def gen_frames():
+    global camera, recognizer, is_running, current_frame, frame_lock
+    
+    while is_running:
+        success, frame = camera.read()
+        if not success:
+            break
+        else:
+            status = recognizer.process_frame(frame)
+            
+            ret, buffer = cv2.imencode('.jpg', frame)
+            if not ret:
+                continue
+                
+            frame_data = base64.b64encode(buffer).decode('utf-8')
+            
+            with frame_lock:
+                current_frame = {'image': frame_data, 'status': status}
+            
+            socketio.emit('update_frame', {'image': frame_data, 'status': status})
+            
+            time.sleep(0.03)  # 約30 FPS
+
+#--------------------
+# 路由定義
+#--------------------
+
+# Messenger Bot 路由
 @app.route('/', methods=['GET'])
 def home():
-    return "統一手語辨識服務正在運行中！🚀"
+    """主頁 - 提供Web介面和Messenger Bot狀態"""
+    return render_template('index.html')
+
+@app.route('/health')
+def health_check():
+    """健康檢查"""
+    return {
+        'status': 'healthy',
+        'environment': 'HuggingFace Spaces' if IS_HUGGINGFACE else 'Local Development',
+        'model_loaded': os.path.exists(MODEL_PATH),
+        'labels_loaded': os.path.exists(LABELS_PATH)
+    }
 
 @app.route('/webhook', methods=['GET'])
 def verify_webhook():
@@ -72,7 +785,7 @@ def handle_webhook():
 
 @app.route('/receive_recognition_result', methods=['POST'])
 def receive_recognition_result():
-    """接收來自本地手語辨識服務的結果"""
+    """接收手語辨識結果（內部呼叫）"""
     try:
         data = request.get_json()
         
@@ -82,7 +795,6 @@ def receive_recognition_result():
         sender_id = data.get('sender_id')
         recognition_result = data.get('recognition_result', '無法辨識')
         confidence = data.get('confidence', 0)
-        timestamp = data.get('timestamp', '')
         
         if not sender_id:
             return jsonify({"status": "error", "message": "缺少 sender_id"}), 400
@@ -91,7 +803,7 @@ def receive_recognition_result():
         print(f"🎯 辨識結果：{recognition_result}")
         print(f"📊 信心度：{confidence}")
         
-        # 只發送純粹的辨識結果句子
+        # 發送結果給用戶
         send_message(sender_id, recognition_result)
         
         return jsonify({
@@ -103,6 +815,70 @@ def receive_recognition_result():
         print(f"處理辨識結果時發生錯誤：{e}")
         return jsonify({"status": "error", "message": str(e)}), 500
 
+@app.route('/process_video', methods=['POST'])
+def process_video():
+    """處理上傳的影片檔案（整合版本）"""
+    try:
+        # 檢查是否有上傳檔案
+        if 'video' not in request.files:
+            return jsonify({"status": "error", "message": "沒有上傳影片檔案"}), 400
+        
+        video_file = request.files['video']
+        sender_id = request.form.get('sender_id', 'unknown')
+        
+        if video_file.filename == '':
+            return jsonify({"status": "error", "message": "沒有選擇檔案"}), 400
+        
+        # 儲存檔案
+        filename = secure_filename(video_file.filename)
+        timestamp = int(time.time())
+        filename = f"{timestamp}_{sender_id}_{filename}"
+        video_path = os.path.join(UPLOAD_FOLDER, filename)
+        
+        video_file.save(video_path)
+        print(f"📁 影片已儲存：{video_path}")
+        
+        # 初始化影片辨識器
+        model_path = MODEL_PATH
+        print(f"🔍 模型路徑: {model_path}")
+        print(f"🔍 模型檔案是否存在: {os.path.exists(model_path)}")
+        
+        video_recognizer = VideoSignLanguageRecognizer(model_path, threshold=0.5)
+        
+        # 處理影片
+        recognition_result, confidence = video_recognizer.process_video(video_path)
+        
+        # 清理臨時檔案
+        try:
+            os.remove(video_path)
+        except:
+            pass
+        
+        if recognition_result is not None:
+            # 如果是來自 Messenger 的請求，直接回傳結果給用戶
+            if sender_id != 'unknown':
+                send_message(sender_id, recognition_result)
+            
+            return jsonify({
+                "status": "success",
+                "recognition_result": recognition_result,
+                "confidence": float(confidence),
+                "sender_id": sender_id
+            })
+        else:
+            return jsonify({
+                "status": "error", 
+                "message": "無法辨識手語內容",
+                "sender_id": sender_id
+            }), 400
+            
+    except Exception as e:
+        print(f"處理影片時發生錯誤：{e}")
+        return jsonify({"status": "error", "message": str(e)}), 500
+
+#--------------------
+# Messenger Bot 輔助函數
+#--------------------
 def handle_message(messaging_event):
     """處理一般訊息"""
     sender_id = messaging_event['sender']['id']
@@ -112,29 +888,23 @@ def handle_message(messaging_event):
     
     print(f"收到訊息 from {sender_id}: {message_text}")
     
-    # 檢查是否有影片附件
+    # 檢查是否有附件
     if attachments:
         for attachment in attachments:
             if attachment.get('type') == 'video':
                 video_url = attachment.get('payload', {}).get('url')
                 if video_url:
-                    # 提示用戶我們已收到影片並開始處理
-                    send_message(sender_id, "收到您的影片了，正在為您處理手語辨識，請稍候...")
-                    
-                    # 在背景處理影片，避免阻塞
-                    thread = threading.Thread(
-                        target=process_video_and_reply, 
-                        args=(video_url, sender_id)
-                    )
-                    thread.start()
+                    # 直接處理影片（HuggingFace 整合版本）
+                    process_messenger_video(video_url, sender_id)
                     return
             else:
-                send_message(sender_id, f"抱歉，目前只支援影片格式的手語辨識喔！")
+                send_message(sender_id, f"收到 {attachment.get('type')} 附件")
                 return
     
     # 處理文字訊息
     if message_text:
-        send_message(sender_id, f"你好！請傳送一段手語影片，我會試著為您翻譯。")
+        response_text = f"您好！請發送手語影片給我，我會幫您辨識手語內容。"
+        send_message(sender_id, response_text)
 
 def handle_postback(messaging_event):
     """處理 postback 事件（按鈕點擊等）"""
@@ -160,120 +930,134 @@ def send_message(recipient_id, message_text):
         'access_token': PAGE_ACCESS_TOKEN
     }
     
-    try:
-        response = requests.post(
-            FACEBOOK_API_URL,
-            headers=headers,
-            params=params,
-            json=data,
-            timeout=30
-        )
-        response.raise_for_status()
-        print(f"訊息發送成功給 {recipient_id}")
-    except requests.exceptions.RequestException as e:
-        print(f"發送訊息失敗 to {recipient_id}: {e}")
-
-def send_quick_reply(recipient_id, message_text, quick_replies):
-    """發送快速回覆選項"""
-    headers = {
-        'Content-Type': 'application/json'
-    }
-    
-    data = {
-        'recipient': {'id': recipient_id},
-        'message': {
-            'text': message_text,
-            'quick_replies': quick_replies
-        }
-    }
-    
-    params = {
-        'access_token': PAGE_ACCESS_TOKEN
-    }
-    
-    requests.post(
+    response = requests.post(
         FACEBOOK_API_URL,
         headers=headers,
         params=params,
         json=data
     )
+    
+    if response.status_code != 200:
+        print(f"發送訊息失敗: {response.status_code} - {response.text}")
+    else:
+        print(f"訊息發送成功給 {recipient_id}")
 
-def download_video_local(video_url, sender_id):
-    """下載影片到本地"""
+def process_messenger_video(video_url, sender_id):
+    """處理來自 Messenger 的影片（HuggingFace 整合版本）"""
     try:
-        # 生成檔案名稱
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = f"video_{sender_id}_{timestamp}.mp4"
-        file_path = os.path.join('received_videos', filename)
-        
-        print(f"開始下載影片到本地：{video_url}")
+        print(f"🎬 開始處理 Messenger 影片：{video_url}")
         
         # 下載影片
         response = requests.get(video_url, stream=True, timeout=30)
         response.raise_for_status()
         
+        # 生成檔案名稱
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename = f"messenger_video_{sender_id}_{timestamp}.mp4"
+        file_path = os.path.join(UPLOAD_FOLDER, filename)
+        
         # 寫入檔案
         with open(file_path, 'wb') as f:
             for chunk in response.iter_content(chunk_size=8192):
                 if chunk:
                     f.write(chunk)
         
-        file_size = os.path.getsize(file_path)
-        print(f"🎬 影片下載完成：{file_path} ({file_size} bytes)")
-        return file_path
-        
-    except Exception as e:
-        print(f"下載影片失敗：{e}")
-        return None
-
-def process_video_and_reply(video_url, sender_id):
-    """下載、處理影片，並回傳結果"""
-    if not recognizer:
-        print("❌ 辨識器未初始化，無法處理影片。")
-        send_message(sender_id, "抱歉，後端辨識服務目前無法使用，請稍後再試。")
-        return
-
-    # 1. 下載影片
-    print(f"🎬 開始下載影片 for user {sender_id} from {video_url}")
-    video_path = download_video_local(video_url, sender_id)
-
-    if not video_path:
-        print(f"❌ 影片下載失敗 for user {sender_id}")
-        send_message(sender_id, "抱歉，無法順利下載您的影片，請再試一次。")
-        return
-
-    # 2. 處理影片並進行手語辨識
-    try:
-        print(f"🤖 開始進行手語辨識 for {video_path}")
-        result = recognizer.process_video(video_path)
+        print(f"✅ 影片下載完成：{file_path}")
         
-        recognition_result = result.get('recognition_result', '無法辨識')
-        confidence = result.get('confidence', 0)
+        # 初始化影片辨識器
+        model_path = MODEL_PATH
+        video_recognizer = VideoSignLanguageRecognizer(model_path, threshold=0.5)
         
-        print(f"✅ 辨識完成 for user {sender_id} - 結果: {recognition_result} (信心度: {confidence:.2f})")
+        # 處理影片
+        recognition_result, confidence = video_recognizer.process_video(file_path)
         
-        # 3. 將結果發送給用戶
-        reply_text = f"辨識結果：\n{recognition_result}"
-        send_message(sender_id, reply_text)
+        # 清理臨時檔案
+        try:
+            os.remove(file_path)
+        except:
+            pass
         
+        if recognition_result:
+            print(f"✅ 手語辨識完成 - 用戶：{sender_id}")
+            print(f"📝 辨識結果：{recognition_result}")
+            print(f"🎯 信心度：{confidence:.2f}")
+            
+            # 發送結果給用戶
+            send_message(sender_id, recognition_result)
+        else:
+            send_message(sender_id, "抱歉，無法辨識您的手語內容，請再試一次。")
+            
     except Exception as e:
-        print(f"❌ 辨識過程中發生錯誤 for {video_path}: {e}")
-        send_message(sender_id, "抱歉，在辨識過程中發生了未預期的錯誤。")
+        print(f"處理 Messenger 影片時發生錯誤：{e}")
+        send_message(sender_id, "處理影片時發生錯誤，請稍後再試。")
+
+#--------------------
+# WebSocket 路由 (即時手語辨識)
+#--------------------
+@socketio.on('connect')
+def handle_connect():
+    """處理WebSocket連接"""
+    print('客戶端已連接')
+
+@socketio.on('disconnect')
+def handle_disconnect():
+    """處理WebSocket斷開連接"""
+    print('客戶端已斷開連接')
+
+@socketio.on('start_stream')
+def handle_start_stream(data):
+    """開始視頻流"""
+    global camera, is_running
     
-    finally:
-        # 4. 刪除本地影片檔案
-        if os.path.exists(video_path):
-            try:
-                os.remove(video_path)
-                print(f"🗑️ 已刪除暫存影片：{video_path}")
-            except Exception as e:
-                print(f"❌ 刪除影片失敗 {video_path}: {e}")
+    # 雲端環境檢查
+    if IS_HUGGINGFACE:
+        return {'status': 'error', 'message': '雲端環境不支援攝像頭功能，請使用影片上傳功能'}
+    
+    if is_running:
+        return {'status': 'already_running'}
+    
+    # 初始化攝像頭
+    camera = cv2.VideoCapture(0)
+    camera.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
+    camera.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
+    
+    if not camera.isOpened():
+        return {'status': 'error', 'message': '無法打開攝像頭'}
+    
+    # 初始化手語辨識器
+    if recognizer is None:
+        initialize_recognizer()
+    
+    # 啟動處理線程
+    is_running = True
+    threading.Thread(target=gen_frames, daemon=True).start()
+    
+    return {'status': 'success'}
 
+@socketio.on('stop_stream')
+def handle_stop_stream(data):
+    """停止視頻流"""
+    global camera, is_running
+    
+    is_running = False
+    
+    # 釋放攝像頭
+    if camera is not None:
+        camera.release()
+        camera = None
+    
+    return {'status': 'success'}
+
+#--------------------
+# 應用程式啟動
+#--------------------
 if __name__ == '__main__':
-    # 建立影片接收資料夾
-    if not os.path.exists('received_videos'):
-        os.makedirs('received_videos')
-        
-    port = int(os.environ.get('PORT', 8000))
-    print(f"🚀 伺服器將在 http://localhost:{port} 上啟動")
-    app.run(host='0.0.0.0', port=port, debug=True) 
+    # HuggingFace Spaces 環境檢測
+    port = int(os.environ.get('PORT', 7860))  # HuggingFace 預設端口
+    
+    print("🚀 手語辨識整合系統啟動中...")
+    print(f"📱 Messenger Bot: {'已配置' if PAGE_ACCESS_TOKEN != 'your_page_access_token' else '未配置'}")
+    print(f"🤖 OpenAI API: {'已配置' if os.environ.get('OPENAI_API_KEY') else '未配置'}")
+    print(f"🔧 運行模式: {'HuggingFace Spaces' if port == 7860 else '本地開發'}")
+    
+    socketio.run(app, host='0.0.0.0', port=port, debug=False, allow_unsafe_werkzeug=True) 

app_config.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import os
+
+# HuggingFace Spaces 配置
+APP_TITLE = "手語辨識整合系統"
+APP_DESCRIPTION = "AI驅動的手語辨識系統，支援Web介面、Messenger Bot和API"
+
+# 預設配置
+DEFAULT_CONFIG = {
+    "MODEL_PATH": "data/models/sign_language_model.pth",
+    "LABELS_PATH": "data/labels.csv", 
+    "UPLOAD_FOLDER": "uploads",
+    "MAX_FILE_SIZE": 100 * 1024 * 1024,  # 100MB
+    "FRAME_SKIP": 5,  # 每5幀處理一次
+    "CONFIDENCE_THRESHOLD": 0.5,
+    "FRAME_BUFFER_SIZE": 30,
+    "PREDICTION_INTERVAL": 10
+}
+
+# 環境變數配置
+def get_config():
+    return {
+        "OPENAI_API_KEY": os.environ.get("OPENAI_API_KEY"),
+        "VERIFY_TOKEN": os.environ.get("VERIFY_TOKEN", "your_verify_token"),
+        "PAGE_ACCESS_TOKEN": os.environ.get("PAGE_ACCESS_TOKEN", "your_page_access_token"),
+        "PORT": int(os.environ.get("PORT", 7860)),
+        "DEBUG": os.environ.get("DEBUG", "False").lower() == "true",
+        **DEFAULT_CONFIG
+    }
+
+# HuggingFace Spaces 專用設定
+HUGGINGFACE_CONFIG = {
+    "title": APP_TITLE,
+    "description": APP_DESCRIPTION,
+    "tags": ["computer-vision", "sign-language", "pytorch", "mediapipe", "openai"],
+    "license": "mit",
+    "sdk": "docker",
+    "app_port": 7860
+}