Python 생태계 🐍

감정 인식 분야에서 Python이 압도적으로 많이 쓰여. 이유는 간단해 - 머신러닝 라이브러리가 풍부하거든!

필수 라이브러리들:

# 딥러닝 프레임워크
import tensorflow as tf
import torch
import keras

# 컴퓨터 비전
import cv2  # OpenCV
import dlib  # 얼굴 랜드마크 검출
from fer import FER  # Facial Expression Recognition

# 자연어 처리
import nltk
from transformers import pipeline
import spacy

# 데이터 처리
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

# 생체신호 처리
import neurokit2 as nk
import heartpy as hp

실제 사용 예시:

# 표정 인식 간단 예제
from fer import FER
import cv2

# 감정 검출기 초기화
detector = FER(mtcnn=True)

# 이미지 로드
image = cv2.imread('face.jpg')

# 감정 분석
result = detector.detect_emotions(image)

# 결과 출력
print(result)
# 출력 예: [{'box': [x, y, w, h], 
#           'emotions': {'angry': 0.01, 'disgust': 0.0, 
#                       'fear': 0.05, 'happy': 0.85, 
#                       'sad': 0.02, 'surprise': 0.03, 
#                       'neutral': 0.04}}]

1. 기본 감정 모델 (Basic Emotions Model)

폴 에크만이 제안한 가장 기본적인 모델이야. 앞서 말한 6가지 기본 감정을 사용하지.

코딩 예시:

{
  "emotion_type": "basic_6",
  "detected_emotion": "happiness",
  "confidence": 0.87,
  "intensity": 0.72,
  "timestamp": "2024-01-15T14:30:22Z"
}

장점: 간단하고 명확, 문화 간 일관성
단점: 복잡한 감정 표현 어려움 (예: 향수, 질투, 자부심 등)

3. 복합 감정 모델 (Complex Emotions)

실제 인간의 감정은 단순하지 않아. 여러 감정이 동시에 나타날 수 있거든. 이걸 표현하는 모델이야.

코딩 예시:

{
  "emotion_type": "complex",
  "primary_emotion": "sadness",
  "secondary_emotions": [
    {"emotion": "anger", "intensity": 0.45},
    {"emotion": "fear", "intensity": 0.32}
  ],
  "mixed_state": "frustrated",
  "confidence": 0.78
}

영화 보다가 슬프면서도 화가 나는 장면 있잖아? 그런 복잡한 감정을 표현할 수 있어. 🎬

필요한 라이브러리 설치

# 가상환경 생성 (권장)
python -m venv emotion_env
source emotion_env/bin/activate  # Windows: emotion_env\Scripts\activate

# 필수 라이브러리 설치
pip install opencv-python
pip install tensorflow
pip install keras
pip install numpy
pip install matplotlib

# 선택적 (GUI 개선용)
pip install tkinter

메인 프로그램 (emotion_detector.py)

import cv2
import numpy as np
from keras.models import load_model
from keras.preprocessing.image import img_to_array
import time

class EmotionDetector:
    def __init__(self, model_path, cascade_path):
        # 감정 레이블
        self.emotion_labels = ['Angry', 'Disgust', 'Fear', 
                               'Happy', 'Sad', 'Surprise', 'Neutral']
        
        # 감정별 색상 (BGR)
        self.emotion_colors = {
            'Happy': (0, 255, 0),      # 초록
            'Sad': (255, 0, 0),        # 파랑
            'Angry': (0, 0, 255),      # 빨강
            'Surprise': (0, 255, 255), # 노랑
            'Fear': (255, 0, 255),     # 자주
            'Disgust': (128, 0, 128),  # 보라
            'Neutral': (200, 200, 200) # 회색
        }
        
        # 모델 로드
        self.model = load_model(model_path)
        
        # 얼굴 검출기 로드 (Haar Cascade)
        self.face_cascade = cv2.CascadeClassifier(cascade_path)
        
        # 통계 데이터
        self.emotion_history = []
        self.max_history = 30  # 최근 30프레임 저장
        
    def detect_emotion(self, frame):
        # 그레이스케일 변환
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        
        # 얼굴 검출
        faces = self.face_cascade.detectMultiScale(
            gray, 
            scaleFactor=1.1, 
            minNeighbors=5, 
            minSize=(30, 30)
        )
        
        results = []
        
        for (x, y, w, h) in faces:
            # 얼굴 영역 추출
            face_roi = gray[y:y+h, x:x+w]
            
            # 모델 입력 크기로 리사이즈 (48x48)
            face_roi = cv2.resize(face_roi, (48, 48))
            face_roi = face_roi.astype("float") / 255.0
            face_roi = img_to_array(face_roi)
            face_roi = np.expand_dims(face_roi, axis=0)
            
            # 감정 예측
            predictions = self.model.predict(face_roi, verbose=0)[0]
            emotion_idx = np.argmax(predictions)
            emotion = self.emotion_labels[emotion_idx]
            confidence = predictions[emotion_idx]
            
            # 결과 저장
            results.append({
                'bbox': (x, y, w, h),
                'emotion': emotion,
                'confidence': confidence,
                'all_predictions': dict(zip(self.emotion_labels, predictions))
            })
            
            # 히스토리 업데이트
            self.emotion_history.append(emotion)
            if len(self.emotion_history) > self.max_history:
                self.emotion_history.pop(0)
        
        return results
    
    def draw_results(self, frame, results):
        for result in results:
            x, y, w, h = result['bbox']
            emotion = result['emotion']
            confidence = result['confidence']
            
            # 감정별 색상 선택
            color = self.emotion_colors.get(emotion, (255, 255, 255))
            
            # 얼굴 박스 그리기
            cv2.rectangle(frame, (x, y), (x+w, y+h), color, 2)
            
            # 감정 텍스트
            text = f"{emotion}: {confidence*100:.1f}%"
            cv2.putText(frame, text, (x, y-10), 
                       cv2.FONT_HERSHEY_SIMPLEX, 0.6, color, 2)
            
            # 상세 정보 (작은 글씨로)
            y_offset = y + h + 20
            for emo, prob in result['all_predictions'].items():
                if prob > 0.1:  # 10% 이상만 표시
                    detail_text = f"{emo}: {prob*100:.0f}%"
                    cv2.putText(frame, detail_text, (x, y_offset),
                               cv2.FONT_HERSHEY_SIMPLEX, 0.4, 
                               (255, 255, 255), 1)
                    y_offset += 15
        
        # 통계 정보
        if self.emotion_history:
            most_common = max(set(self.emotion_history), 
                            key=self.emotion_history.count)
            stats_text = f"Dominant: {most_common}"
            cv2.putText(frame, stats_text, (10, 30),
                       cv2.FONT_HERSHEY_SIMPLEX, 0.7, (0, 255, 0), 2)
        
        return frame
    
    def run(self):
        # 웹캠 시작
        cap = cv2.VideoCapture(0)
        
        if not cap.isOpened():
            print("Error: Cannot open webcam")
            return
        
        print("Press 'q' to quit")
        
        fps_start_time = time.time()
        fps_counter = 0
        fps = 0
        
        while True:
            ret, frame = cap.read()
            if not ret:
                break
            
            # 감정 검출
            results = self.detect_emotion(frame)
            
            # 결과 그리기
            frame = self.draw_results(frame, results)
            
            # FPS 계산
            fps_counter += 1
            if (time.time() - fps_start_time) > 1:
                fps = fps_counter
                fps_counter = 0
                fps_start_time = time.time()
            
            # FPS 표시
            cv2.putText(frame, f"FPS: {fps}", (10, frame.shape[0]-10),
                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 1)
            
            # 화면 표시
            cv2.imshow('Emotion Detection', frame)
            
            # 'q' 키로 종료
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
        
        # 정리
        cap.release()
        cv2.destroyAllWindows()

# 실행
if __name__ == "__main__":
    # 경로 설정 (본인 환경에 맞게 수정)
    MODEL_PATH = "models/emotion_model.h5"
    CASCADE_PATH = cv2.data.haarcascades + "haarcascade_frontalface_default.xml"
    
    detector = EmotionDetector(MODEL_PATH, CASCADE_PATH)
    detector.run()