Upload 12 files

.gitattributes

@@ -1,34 +1,5 @@
-*.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
-*.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
+# Auto detect text files and perform LF normalization
+* text=auto
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,44 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Project specific
+temp_output.mp4
+*.h5
+*.bin
+*.pth
+*.pt
+*.onnx
+*.pkl
+
+# Logs
+*.log 

Dockerfile

@@ -0,0 +1,28 @@
+FROM python:3.10-slim
+
+# 安裝系統依賴
+RUN apt-get update && apt-get install -y \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# 設置工作目錄
+WORKDIR /app
+
+# 複製依賴文件
+COPY requirements.txt .
+
+# 安裝 Python 依賴
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 複製應用程式文件
+COPY . .
+
+# 暴露端口
+EXPOSE 8080
+
+# 啟動應用
+CMD ["python", "app.py"]

README.md

@@ -1,36 +1,33 @@
----
-title: Dnn Space
-emoji: 🚀
-colorFrom: blue
-colorTo: green
-sdk: docker
-pinned: false
-short_description: Create powerful AI models without code
-hf_oauth: true
-hf_oauth_expiration_minutes: 36000
-hf_oauth_scopes:
-- read-repos
-- write-repos
-- manage-repos
-- inference-api
-- read-billing
-tags:
-- autotrain
-license: mit
----
-
-# Docs
-
-https://huggingface.co/docs/autotrain
-
-# Citation
-
-@misc{thakur2024autotrainnocodetrainingstateoftheart,
-      title={AutoTrain: No-code training for state-of-the-art models}, 
-      author={Abhishek Thakur},
-      year={2024},
-      eprint={2410.15735},
-      archivePrefix={arXiv},
-      primaryClass={cs.AI},
-      url={https://arxiv.org/abs/2410.15735}, 
-}
+# Driver Drowsiness Detection System
+
+This is a real-time driver drowsiness detection system that uses computer vision and deep learning to detect signs of drowsiness in drivers. The system can process webcam feeds, video files, and single images.
+
+## Features
+
+- Real-time webcam monitoring
+- Video file processing
+- Single image analysis
+- Face detection and drowsiness prediction
+- Visual feedback with bounding boxes and status indicators
+
+## How to Use
+
+1. **Webcam Mode**: Click the "Start Webcam" button to begin real-time monitoring
+2. **Video Mode**: Upload a video file for processing
+3. **Image Mode**: Upload a single image for analysis
+
+The system will display the results with:
+- Green box: Alert (not drowsy)
+- Red box: Drowsy
+- Probability score for drowsiness
+
+## Technical Details
+
+- Built with PyTorch and Vision Transformer (ViT)
+- Uses OpenCV for face detection
+- Gradio interface for easy interaction
+- Real-time processing capabilities
+
+## Model
+
+The system uses a Vision Transformer (ViT) model trained on driver drowsiness detection. The model is capable of detecting subtle signs of drowsiness in facial expressions. 

app.py

@@ -1,158 +1,264 @@
 import gradio as gr
-import cv2
-import numpy as np
 import torch
-from transformers import AutoImageProcessor, AutoModelForImageClassification
-import tempfile
-import os
-import shutil
+from transformers import ViTForImageClassification, ViTImageProcessor
+import numpy as np
+import cv2
 from PIL import Image
+import io
+import os
+import sys
 import time
 
-# 加載模型和處理器
-# 嘗試使用本地模型，如果失敗則使用遠程模型
-try:
-    model_path = "./huggingface_model"  # 本地模型路徑
-    processor = AutoImageProcessor.from_pretrained(model_path)
-    model = AutoModelForImageClassification.from_pretrained(model_path)
-    print(f"使用本地模型: {model_path}")
-except Exception as e:
-    print(f"無法載入本地模型: {e}")
-    print("嘗試使用遠程模型...")
-    model_name = "ckcl/dnn_space2"  # 遠程模型名稱
-    processor = AutoImageProcessor.from_pretrained(model_name)
-    model = AutoModelForImageClassification.from_pretrained(model_name)
-    print(f"使用遠程模型: {model_name}")
+class DrowsinessDetector:
+    def __init__(self):
+        self.model = None
+        self.processor = None
+        self.input_shape = (224, 224, 3)
+        self.face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+        self.id2label = {0: "notdrowsy", 1: "drowsy"}
+        self.label2id = {"notdrowsy": 0, "drowsy": 1}
 
-# 如果使用GPU
-device = "cuda" if torch.cuda.is_available() else "cpu"
-print(f"使用設備: {device}")
-model = model.to(device)
+    def load_model(self, model_path):
+        """Load the ViT model and processor from the specified path or directory"""
+        try:
+            self.model = ViTForImageClassification.from_pretrained(
+                model_path,  # 直接給資料夾路徑
+                num_labels=2,
+                id2label=self.id2label,
+                label2id=self.label2id,
+                ignore_mismatched_sizes=True
+            )
+            self.model.eval()
+            self.processor = ViTImageProcessor.from_pretrained("google/vit-base-patch16-224")
+            print(f"ViT model loaded successfully from {model_path}")
+        except Exception as e:
+            print(f"Error loading ViT model: {str(e)}")
+            raise
 
-def process_frame(frame):
-    """處理單個視頻幀"""
-    # 轉換為RGB
-    frame_rgb = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-    
-    # 使用處理器處理圖像
-    inputs = processor(images=frame_rgb, return_tensors="pt")
-    inputs = {k: v.to(device) for k, v in inputs.items()}
-    
-    # 進行預測
-    with torch.no_grad():
-        outputs = model(**inputs)
-        logits = outputs.logits
-        probabilities = torch.nn.functional.softmax(logits, dim=-1)
-        prediction = torch.argmax(probabilities, dim=-1).item()
-        confidence = probabilities[0][prediction].item()
-    
-    # 添加預測結果到圖像
-    label = "Alert" if prediction == 0 else "Drowsy"
-    color = (0, 255, 0) if prediction == 0 else (0, 0, 255)
-    
-    cv2.putText(frame, f"{label}: {confidence:.2f}", (10, 30),
-                cv2.FONT_HERSHEY_SIMPLEX, 1, color, 2)
-    
-    return frame, label, confidence
+    def detect_face(self, frame):
+        """Detect face in the frame"""
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        faces = self.face_cascade.detectMultiScale(gray, 1.1, 4)
+        if len(faces) > 0:
+            (x, y, w, h) = faces[0]  # Get the first face
+            face = frame[y:y+h, x:x+w]
+            return face, (x, y, w, h)
+        return None, None
 
-def process_video(video_file):
-    """處理上傳的視頻文件"""
-    # 創建臨時文件
-    video_path = ""
-    
-    # 檢查 video_file 是字符串還是二進制數據
-    if isinstance(video_file, str):
-        # 如果是字符串（文件路徑），直接使用它
-        video_path = video_file
-    else:
-        # 如果是二進制數據，寫入臨時文件
-        with tempfile.NamedTemporaryFile(delete=False, suffix='.mp4') as tmp_file:
-            tmp_file.write(video_file)
-            video_path = tmp_file.name
-    
-    # 打開視頻
-    cap = cv2.VideoCapture(video_path)
-    if not cap.isOpened():
-        if video_path != video_file:  # 如果創建了臨時文件，需要刪除
-            os.unlink(video_path)
-        return None, "Error: Could not open video file"
-    
-    # 獲取視頻信息
-    fps = cap.get(cv2.CAP_PROP_FPS)
-    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
-    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
-    
-    # 創建輸出視頻
-    os.makedirs("output_videos", exist_ok=True)
-    timestamp = int(time.time())
-    output_path = f"output_videos/output_{timestamp}.mp4"
-    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
-    out = cv2.VideoWriter(output_path, fourcc, fps, (width, height))
-    
-    drowsy_frames = 0
-    total_frames = 0
+    def preprocess_image(self, image):
+        """Preprocess the input image for ViT"""
+        if image is None:
+            return None
+        pil_img = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+        inputs = self.processor(images=pil_img, return_tensors="pt")
+        return inputs
+
+    def predict(self, image):
+        """Make prediction on the input image using ViT"""
+        if self.model is None or self.processor is None:
+            raise ValueError("Model not loaded. Call load_model() first.")
+        # Detect face
+        face, face_coords = self.detect_face(image)
+        if face is None:
+            return None, None, "No face detected"
+        # Preprocess the face image
+        inputs = self.preprocess_image(face)
+        if inputs is None:
+            return None, None, "Error processing image"
+        # Make prediction
+        with torch.no_grad():
+            outputs = self.model(**inputs)
+            logits = outputs.logits
+            probs = torch.softmax(logits, dim=1)
+            pred_class = torch.argmax(probs, dim=1).item()
+            pred_label = self.id2label[pred_class]
+            pred_prob = probs[0, pred_class].item()
+        # Return drowsy probability (class 1)
+        drowsy_prob = probs[0, 1].item()
+        return drowsy_prob, face_coords, None
+
+# Initialize detector
+detector = DrowsinessDetector()
+
+def find_model_file():
+    """Find the model directory or file in common locations"""
+    possible_paths = [
+        "huggingface_model",  # 優先資料夾
+        "pytorch_model.bin",
+        "model_weights.h5",
+        "drowsiness_model.h5",
+        "model/drowsiness_model.h5",
+        "models/drowsiness_model.h5",
+        "huggingface_model/model_weights.h5",
+        "huggingface_model/drowsiness_model.h5",
+        "../model_weights.h5",
+        "../drowsiness_model.h5"
+    ]
+    for path in possible_paths:
+        if os.path.exists(path):
+            return path
+    return None
+
+def load_model():
+    """Load the model"""
+    model_path = find_model_file()
     
-    while True:
-        ret, frame = cap.read()
-        if not ret:
-            break
+    if model_path is None:
+        print("\nError: Model file not found!")
+        print("\nPlease ensure one of the following files exists:")
+        print("1. model_weights.h5")
+        print("2. drowsiness_model.h5")
+        print("3. model/drowsiness_model.h5")
+        print("4. models/drowsiness_model.h5")
+        print("\nYou can download the model from Hugging Face Hub or train it using train_model.py")
+        sys.exit(1)
         
-        # 處理幀
-        processed_frame, label, confidence = process_frame(frame)
-        out.write(processed_frame)
+    try:
+        detector.load_model(model_path)
+    except Exception as e:
+        print(f"\nError loading model: {str(e)}")
+        sys.exit(1)
+
+def process_frame(frame):
+    """Process a single frame"""
+    if frame is None:
+        return None
         
-        if label == "Drowsy":
-            drowsy_frames += 1
-        total_frames += 1
-    
-    # 釋放資源
-    cap.release()
-    out.release()
-    
-    # 如果創建了臨時文件，需要刪除
-    if video_path != video_file:
-        os.unlink(video_path)
+    try:
+        # Convert frame to RGB if needed
+        if len(frame.shape) == 2:
+            frame = cv2.cvtColor(frame, cv2.COLOR_GRAY2RGB)
+        elif frame.shape[2] == 4:
+            frame = cv2.cvtColor(frame, cv2.COLOR_RGBA2RGB)
+        
+        # Make prediction
+        drowsy_prob, face_coords, error = detector.predict(frame)
+        
+        if error:
+            return frame
+            
+        if face_coords is not None:
+            x, y, w, h = face_coords
+            # Draw rectangle around face
+            color = (0, 0, 255) if drowsy_prob > 0.7 else (0, 255, 0)
+            cv2.rectangle(frame, (x, y), (x+w, y+h), color, 2)
+            
+            # Add text
+            status = "DROWSY" if drowsy_prob > 0.7 else "ALERT"
+            cv2.putText(frame, f"{status} ({drowsy_prob:.2%})", 
+                       (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.9, color, 2)
+        
+        return frame
+        
+    except Exception as e:
+        print(f"Error processing frame: {str(e)}")
+        return frame
+
+def process_video(video_input):
+    """Process video input"""
+    if video_input is None:
+        return None
     
-    # 計算困倦比例
-    drowsy_ratio = drowsy_frames / total_frames if total_frames > 0 else 0
+    try:
+        # Get input video properties
+        cap = cv2.VideoCapture(video_input)
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+        height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+        
+        # Create temporary output video file
+        temp_output = "temp_output.mp4"
+        fourcc = cv2.VideoWriter_fourcc(*'mp4v')
+        out = cv2.VideoWriter(temp_output, fourcc, fps, (width, height))
+        
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+                
+            processed_frame = process_frame(frame)
+            if processed_frame is not None:
+                out.write(processed_frame)
+                
+        # Release resources
+        cap.release()
+        out.release()
+        
+        # Check if video was created
+        if os.path.exists(temp_output) and os.path.getsize(temp_output) > 0:
+            return temp_output
+        else:
+            print("Error: Failed to create output video")
+            return None
+        
+    except Exception as e:
+        print(f"Error processing video: {str(e)}")
+        return None
+    finally:
+        # Clean up temporary file
+        if 'out' in locals():
+            out.release()
+        if 'cap' in locals():
+            cap.release()
+
+def webcam_feed():
+    """Process webcam feed"""
+    try:
+        cap = cv2.VideoCapture(0)
+        while True:
+            ret, frame = cap.read()
+            if not ret:
+                break
+                
+            processed_frame = process_frame(frame)
+            if processed_frame is not None:
+                yield processed_frame
+                
+    except Exception as e:
+        print(f"Error processing webcam feed: {str(e)}")
+        yield None
+    finally:
+        cap.release()
+
+# Load the model at startup
+load_model()
+
+# Create interface
+with gr.Blocks(title="Driver Drowsiness Detection") as demo:
+    gr.Markdown("""
+    # 🚗 Driver Drowsiness Detection System
     
-    # 生成報告
-    report = f"""
-    Video Analysis Report:
-    ---------------------
-    Total Frames: {total_frames}
-    Drowsy Frames: {drowsy_frames}
-    Drowsy Ratio: {drowsy_ratio:.2%}
+    This system detects driver drowsiness using computer vision and deep learning.
     
-    Alert Level:
-    {'⚠️ HIGH ALERT' if drowsy_ratio > 0.3 else '✅ Normal' if drowsy_ratio < 0.1 else '⚠️ Warning'}
-    """
+    ## Features:
+    - Real-time webcam monitoring
+    - Video file processing
+    - Single image analysis
+    - Face detection and drowsiness prediction
+    """)
     
-    return output_path, report
-
-# 創建Gradio界面
-with gr.Blocks(title="Driver Drowsiness Detection") as demo:
-    gr.Markdown(
-        """
-        # 🚗 Driver Drowsiness Detection
-        Upload a video of a driver. The system will analyze the video and detect drowsiness frame by frame.\n
-        - **Green label:** Alert
-        - **Red label:** Drowsy
-        - **Report:** Shows drowsy ratio and alert level.
-        """
-    )
-    with gr.Row():
-        with gr.Column(scale=1):
-            video_input = gr.Video(label="Upload Driver Video (MP4)")
-            analyze_btn = gr.Button("Analyze Video")
-        with gr.Column(scale=1):
-            video_output = gr.Video(label="Processed Video with Drowsiness Labels")
-            report_output = gr.Textbox(label="Analysis Report", lines=8, interactive=False)
-    analyze_btn.click(
-        fn=process_video,
-        inputs=video_input,
-        outputs=[video_output, report_output]
-    )
+    with gr.Tabs():
+        with gr.Tab("Webcam"):
+            gr.Markdown("Real-time drowsiness detection using your webcam")
+            webcam_output = gr.Image(label="Live Detection")
+            webcam_button = gr.Button("Start Webcam")
+            webcam_button.click(fn=webcam_feed, inputs=None, outputs=webcam_output)
+            
+        with gr.Tab("Video"):
+            gr.Markdown("Upload a video file for drowsiness detection")
+            with gr.Row():
+                video_input = gr.Video(label="Input Video")
+                video_output = gr.Video(label="Detection Result")
+            video_button = gr.Button("Process Video")
+            video_button.click(fn=process_video, inputs=video_input, outputs=video_output)
+            
+        with gr.Tab("Image"):
+            gr.Markdown("Upload an image for drowsiness detection")
+            with gr.Row():
+                image_input = gr.Image(type="numpy", label="Input Image")
+                image_output = gr.Image(label="Detection Result")
+            image_button = gr.Button("Process Image")
+            image_button.click(fn=process_frame, inputs=image_input, outputs=image_output)
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch() 

drowsiness_detector.py

@@ -0,0 +1,122 @@
+import os
+import cv2
+import numpy as np
+from speed_detector import SpeedDetector
+from face_analyzer import FaceAnalyzer
+import pandas as pd
+import time
+
+class DrowsinessDetector:
+    def __init__(self):
+        self.speed_detector = SpeedDetector()
+        self.face_analyzer = FaceAnalyzer()
+        
+    def process_frame(self, frame_path, face_path):
+        """
+        處理單個幀
+        :param frame_path: 場景圖片路徑
+        :param face_path: 人臉圖片路徑
+        :return: (速度, 是否犯困)
+        """
+        try:
+            # 讀取圖片
+            frame = cv2.imread(frame_path)
+            face = cv2.imread(face_path)
+            
+            if frame is None or face is None:
+                print(f"處理 {os.path.basename(frame_path)} 時出錯: 無法讀取圖片")
+                return None, None
+                
+            # 檢測速度
+            speed = self.speed_detector.detect_speed(frame)
+            
+            # 檢測是否犯困
+            is_drowsy = self.face_analyzer.is_drowsy(face)
+            
+            return speed, is_drowsy
+        except Exception as e:
+            print(f"處理 {os.path.basename(frame_path)} 時出錯: {str(e)}")
+            return None, None
+        
+    def process_video_folder(self, folder_path):
+        """
+        處理一個視頻文件夾中的所有幀
+        :param folder_path: 視頻文件夾路徑
+        :return: 處理結果列表
+        """
+        results = []
+        
+        # 獲取所有幀圖片
+        frame_files = [f for f in os.listdir(folder_path) if f.endswith('.jpg') and not f.endswith('_face.jpg')]
+        total_frames = len(frame_files)
+        
+        for i, frame_file in enumerate(frame_files, 1):
+            # 構建完整的文件路徑
+            frame_path = os.path.join(folder_path, frame_file)
+            face_path = os.path.join(folder_path, frame_file.replace('.jpg', '_face.jpg'))
+            
+            # 顯示進度
+            print(f"\r處理進度: {i}/{total_frames} ({i/total_frames*100:.1f}%)", end="")
+            
+            try:
+                speed, is_drowsy = self.process_frame(frame_path, face_path)
+                if speed is not None and is_drowsy is not None:
+                    results.append({
+                        'frame': frame_file,
+                        'speed': speed,
+                        'is_drowsy': is_drowsy
+                    })
+            except KeyboardInterrupt:
+                print("\n檢測到中斷，保存當前結果...")
+                return results
+            except Exception as e:
+                print(f"\n處理 {frame_file} 時出錯: {str(e)}")
+                continue
+                
+        print()  # 換行
+        return results
+        
+def main():
+    # 初始化檢測器
+    detector = DrowsinessDetector()
+    
+    # 獲取所有視頻文件夾
+    dataset_path = os.path.join('dataset', 'driver')
+    video_folders = [f for f in os.listdir(dataset_path) if os.path.isdir(os.path.join(dataset_path, f))]
+    total_folders = len(video_folders)
+    
+    all_results = []
+    batch_size = 100  # 每處理100個文件夾保存一次結果
+    
+    try:
+        # 處理每個視頻文件夾
+        for i, folder in enumerate(video_folders, 1):
+            print(f"\n處理文件夾 {i}/{total_folders}: {folder}")
+            folder_path = os.path.join(dataset_path, folder)
+            results = detector.process_video_folder(folder_path)
+            all_results.extend(results)
+            
+            # 每處理完一批文件夾就保存一次結果
+            if i % batch_size == 0 or i == total_folders:
+                print(f"\n保存第 {i//batch_size + 1} 批結果...")
+                df = pd.DataFrame(all_results)
+                df.to_csv(f'drowsiness_results_batch_{i//batch_size + 1}.csv', index=False)
+                all_results = []  # 清空結果列表
+                
+    except KeyboardInterrupt:
+        print("\n檢測到中斷，保存當前結果...")
+        if all_results:
+            df = pd.DataFrame(all_results)
+            df.to_csv('drowsiness_results_final.csv', index=False)
+            print("結果已保存到 drowsiness_results_final.csv")
+    except Exception as e:
+        print(f"\n發生錯誤: {str(e)}")
+        if all_results:
+            df = pd.DataFrame(all_results)
+            df.to_csv('drowsiness_results_error.csv', index=False)
+            print("結果已保存到 drowsiness_results_error.csv")
+    finally:
+        print("\n處理完成")
+    
+if __name__ == "__main__":
+    main() 

drowsiness_model.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:33ed6e261f05e4d4be1493ed052502babd13f646198240093db910011b8b6797
+size 532812672

face_analyzer.py

@@ -0,0 +1,60 @@
+import cv2
+import numpy as np
+
+class FaceAnalyzer:
+    def __init__(self):
+        # 加載OpenCV的人臉檢測器和眼睛檢測器
+        self.face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
+        self.eye_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_eye.xml')
+        
+    def _get_eye_aspect_ratio(self, eye_region):
+        """
+        計算眼睛縱橫比（EAR）
+        :param eye_region: 眼睛區域的圖像
+        :return: EAR值
+        """
+        # 將眼睛區域轉換為灰度圖
+        gray_eye = cv2.cvtColor(eye_region, cv2.COLOR_BGR2GRAY)
+        
+        # 檢測眼睛
+        eyes = self.eye_cascade.detectMultiScale(gray_eye)
+        
+        if len(eyes) != 2:  # 如果沒有檢測到兩個眼睛
+            return 0.0
+            
+        # 獲取眼睛的寬度和高度
+        eye1 = eyes[0]
+        eye2 = eyes[1]
+        
+        # 計算眼睛的寬高比
+        ear1 = eye1[2] / eye1[3]
+        ear2 = eye2[2] / eye2[3]
+        
+        # 返回平均EAR
+        return (ear1 + ear2) / 2.0
+        
+    def is_drowsy(self, face_image):
+        """
+        檢測是否犯困
+        :param face_image: 人臉圖片
+        :return: 是否犯困（True/False）
+        """
+        # 將圖片轉換為灰度圖
+        gray = cv2.cvtColor(face_image, cv2.COLOR_BGR2GRAY)
+        
+        # 檢測人臉
+        faces = self.face_cascade.detectMultiScale(gray, 1.3, 5)
+        
+        if len(faces) == 0:
+            return False
+            
+        # 獲取最大的人臉區域
+        (x, y, w, h) = faces[0]
+        face_roi = face_image[y:y+h, x:x+w]
+        
+        # 計算眼睛縱橫比
+        ear = self._get_eye_aspect_ratio(face_roi)
+        
+        # 如果EAR小於閾值，認為是犯困
+        EAR_THRESHOLD = 0.25
+        return ear < EAR_THRESHOLD 

inference.py

@@ -0,0 +1,93 @@
+import tensorflow as tf
+import numpy as np
+import cv2
+from PIL import Image
+import io
+import base64
+import os
+
+class DrowsinessDetector:
+    def __init__(self):
+        self.model = None
+        self.input_shape = (64, 64, 3)
+        
+    def load_model(self, model_path):
+        """Load the model from the specified path"""
+        self.model = tf.keras.models.load_model(model_path)
+        
+    def preprocess_image(self, image):
+        """Preprocess the input image"""
+        if isinstance(image, str):
+            # If image is a base64 string
+            image_data = base64.b64decode(image)
+            image = Image.open(io.BytesIO(image_data))
+            image = np.array(image)
+        elif isinstance(image, bytes):
+            # If image is raw bytes
+            image = Image.open(io.BytesIO(image))
+            image = np.array(image)
+        
+        # Convert to RGB if needed
+        if len(image.shape) == 2:
+            image = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
+        elif image.shape[2] == 4:
+            image = cv2.cvtColor(image, cv2.COLOR_RGBA2RGB)
+            
+        # Resize and normalize
+        image = cv2.resize(image, self.input_shape[:2])
+        image = image.astype(np.float32) / 255.0
+        image = np.expand_dims(image, axis=0)
+        
+        return image
+    
+    def predict(self, image):
+        """Make prediction on the input image"""
+        if self.model is None:
+            raise ValueError("Model not loaded. Call load_model() first.")
+            
+        # Preprocess the image
+        processed_image = self.preprocess_image(image)
+        
+        # Make prediction
+        prediction = self.model.predict(processed_image)
+        
+        # Return prediction results
+        return {
+            "drowsy_probability": float(prediction[0][0]),
+            "is_drowsy": bool(prediction[0][0] > 0.5)
+        }
+
+# Create a global instance
+detector = DrowsinessDetector()
+
+def load_model():
+    """Load the model when the API starts"""
+    global detector
+    detector.load_model("model_weights.h5")
+
+def predict(image):
+    """API endpoint for prediction"""
+    try:
+        result = detector.predict(image)
+        return {
+            "status": "success",
+            "prediction": result
+        }
+    except Exception as e:
+        return {
+            "status": "error",
+            "message": str(e)
+        }
+
+# For local testing
+if __name__ == "__main__":
+    # Load model
+    load_model()
+    
+    # Test with a sample image
+    test_image_path = "test_image.jpg"  # Replace with your test image
+    if os.path.exists(test_image_path):
+        with open(test_image_path, "rb") as f:
+            image_data = f.read()
+        result = predict(image_data)
+        print("Prediction result:", result) 

requirements.txt

@@ -1,12 +1,10 @@
-torch>=1.7.0
-transformers>=4.18.0
-huggingface-hub>=0.4.0
-opencv-python>=4.5.0
-gradio>=3.50.2
-numpy>=1.19.0
-Pillow>=8.0.0
-matplotlib>=3.5.1
-scikit-learn>=1.0.2
-tqdm>=4.64.0
-pandas>=1.4.2
-datasets>=2.11.0 
+gradio==3.50.2
+numpy==1.26.4
+opencv-python==4.8.0
+Pillow==10.0.0
+ffmpeg-python==0.2.0
+huggingface-hub>=0.21.0
+transformers==4.35.2
+torch>=2.0.0
+torchvision>=0.15.0
+tqdm==4.66.1

speed_detector.py

@@ -0,0 +1,40 @@
+import cv2
+import numpy as np
+
+class SpeedDetector:
+    def __init__(self):
+        # 初始化車速檢測模型
+        self.model = self._load_model()
+        
+    def _load_model(self):
+        """
+        加載車速檢測模型
+        這裡我們使用一個簡單的基於模板匹配的方法
+        實際應用中應該使用更複雜的深度學習模型
+        """
+        # TODO: 實現實際的模型加載
+        return None
+        
+    def detect_speed(self, frame):
+        """
+        從圖片中檢測車速
+        :param frame: 輸入圖片
+        :return: 檢測到的車速（km/h）
+        """
+        # 將圖片轉換為灰度圖
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        
+        # 使用Canny邊緣檢測
+        edges = cv2.Canny(gray, 50, 150)
+        
+        # 使用霍夫變換檢測直線
+        lines = cv2.HoughLinesP(edges, 1, np.pi/180, 100, minLineLength=100, maxLineGap=10)
+        
+        if lines is None:
+            return 0
+            
+        # 計算車速（這裡使用一個簡單的啟發式方法）
+        # 實際應用中應該使用更複雜的算法
+        speed = len(lines) * 5  # 簡單的線性關係
+        
+        return min(speed, 120)  # 限制最大速度為120km/h