# 사이킷런으로 간단한 감정 분류기 만들기
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.pipeline import Pipeline

# 학습 데이터 예시
texts = [
    "이 제품 정말 최고예요!",
    "완전 실망했어요 다시는 안 삽니다",
    "배송이 빠르고 품질도 좋네요",
    "돈 아깝고 품질 최악",
    "그냥 평범해요 보통이에요"
]
labels = ['긍정', '부정', '긍정', '부정', '중립']

# 파이프라인 구성
pipeline = Pipeline([
    ('tfidf', TfidfVectorizer(analyzer='char', ngram_range=(2, 4))),
    ('clf', LogisticRegression(max_iter=1000))
])

pipeline.fit(texts, labels)

# 예측
test = ["이거 진짜 대박이에요!"]
print(pipeline.predict(test))  # ['긍정']

# KoBERT 기반 감정 분석 (transformers 라이브러리 활용)
from transformers import pipeline

# 한국어 감정 분석 파이프라인 로드
# snunlp/KR-FinBert-SC 또는 monologg/koelectra-base-finetuned-sentiment
sentiment_analyzer = pipeline(
    "text-classification",
    model="snunlp/KR-FinBert-SC",
    tokenizer="snunlp/KR-FinBert-SC"
)

texts = [
    "오늘 날씨도 좋고 기분도 최고야!",
    "왜 이렇게 일이 안 풀리지... 너무 힘들다",
    "그냥 평범한 하루였어"
]

for text in texts:
    result = sentiment_analyzer(text)
    print(f"텍스트: {text}")
    print(f"감정: {result[0]['label']}, 확신도: {result[0]['score']:.3f}")
    print()

# 한국어 텍스트 전처리 예시
import re
from konlpy.tag import Okt

okt = Okt()

def preprocess_korean(text):
    # 1. URL 제거
    text = re.sub(r'http\S+|www\S+', '', text)
    
    # 2. 이메일 제거
    text = re.sub(r'\S+@\S+', '', text)
    
    # 3. 반복 문자 정규화 (ㅋㅋㅋㅋ → ㅋㅋ)
    text = re.sub(r'(.)\1{2,}', r'\1\1', text)
    
    # 4. 특수문자 제거 (한글, 영문, 숫자, 기본 문장부호만 유지)
    text = re.sub(r'[^\w\s가-힣ㄱ-ㅎㅏ-ㅣ.,!?]', ' ', text)
    
    # 5. 형태소 분석 및 품사 태깅
    morphs = okt.pos(text, norm=True, stem=True)
    
    # 6. 명사, 형용사, 동사만 추출 (감정 관련 품사)
    filtered = [word for word, pos in morphs 
                if pos in ['Noun', 'Adjective', 'Verb', 'Adverb']]
    
    return ' '.join(filtered)

# 테스트
raw_text = "이 영화 ㅈㄴ 재밌었어요!!!! 완전 강추ㅋㅋㅋㅋㅋ"
processed = preprocess_korean(raw_text)
print(f"원본: {raw_text}")
print(f"전처리 후: {processed}")

# librosa로 음성 특징 추출하기
import librosa
import numpy as np

def extract_audio_features(audio_path):
    # 음성 파일 로드
    y, sr = librosa.load(audio_path, sr=22050)
    
    # 1. MFCC 추출 (40개 계수)
    mfcc = librosa.feature.mfcc(y=y, sr=sr, n_mfcc=40)
    mfcc_mean = np.mean(mfcc, axis=1)  # 시간 축 평균
    mfcc_std = np.std(mfcc, axis=1)   # 시간 축 표준편차
    
    # 2. 피치(F0) 추출
    pitches, magnitudes = librosa.piptrack(y=y, sr=sr)
    pitch_mean = np.mean(pitches[pitches > 0]) if np.any(pitches > 0) else 0
    
    # 3. 에너지 (RMS)
    rms = librosa.feature.rms(y=y)
    rms_mean = np.mean(rms)
    
    # 4. 스펙트럼 중심 (Spectral Centroid)
    spectral_centroid = librosa.feature.spectral_centroid(y=y, sr=sr)
    sc_mean = np.mean(spectral_centroid)
    
    # 5. Zero Crossing Rate
    zcr = librosa.feature.zero_crossing_rate(y)
    zcr_mean = np.mean(zcr)
    
    # 6. Chroma 특징
    chroma = librosa.feature.chroma_stft(y=y, sr=sr)
    chroma_mean = np.mean(chroma, axis=1)
    
    # 모든 특징 합치기
    features = np.concatenate([
        mfcc_mean, mfcc_std,
        [pitch_mean, rms_mean, sc_mean, zcr_mean],
        chroma_mean
    ])
    
    return features

# 특징 추출 후 모델에 입력
features = extract_audio_features("sample_audio.wav")
print(f"추출된 특징 벡터 크기: {features.shape}")
# 출력: 추출된 특징 벡터 크기: (96,)

# Wav2Vec 2.0 기반 음성 감정 분석
from transformers import Wav2Vec2ForSequenceClassification, Wav2Vec2Processor
import torch
import librosa

# 모델 로드 (감정 분류용 파인튜닝된 모델)
model_name = "ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition"
processor = Wav2Vec2Processor.from_pretrained(model_name)
model = Wav2Vec2ForSequenceClassification.from_pretrained(model_name)

def predict_emotion(audio_path):
    # 음성 로드 (16kHz로 리샘플링)
    speech, sr = librosa.load(audio_path, sr=16000)
    
    # 전처리
    inputs = processor(
        speech, 
        sampling_rate=16000, 
        return_tensors="pt", 
        padding=True
    )
    
    # 추론
    with torch.no_grad():
        logits = model(**inputs).logits
    
    # 감정 레이블 변환
    predicted_id = torch.argmax(logits, dim=-1).item()
    emotion_labels = ['분노', '혐오', '공포', '기쁨', '중립', '슬픔', '놀라움']
    
    # 소프트맥스로 확률 계산
    probs = torch.softmax(logits, dim=-1)[0]
    
    return {
        'emotion': emotion_labels[predicted_id],
        'confidence': probs[predicted_id].item(),
        'all_probs': {label: prob.item() 
                      for label, prob in zip(emotion_labels, probs)}
    }

result = predict_emotion("test_audio.wav")
print(f"감지된 감정: {result['emotion']}")
print(f"확신도: {result['confidence']:.2%}")

# 후기 융합(Late Fusion) 방식 멀티모달 감정 분석
import torch
import torch.nn as nn
import numpy as np

class MultimodalSentimentFusion(nn.Module):
    def __init__(self, text_dim=768, audio_dim=96, num_classes=7):
        super().__init__()
        
        # 텍스트 브랜치
        self.text_encoder = nn.Sequential(
            nn.Linear(text_dim, 256),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(256, 128)
        )
        
        # 음성 브랜치
        self.audio_encoder = nn.Sequential(
            nn.Linear(audio_dim, 128),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(128, 128)
        )
        
        # 크로스-모달 어텐션
        self.cross_attention = nn.MultiheadAttention(
            embed_dim=128, num_heads=4, batch_first=True
        )
        
        # 최종 분류기
        self.classifier = nn.Sequential(
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(128, num_classes)
        )
    
    def forward(self, text_features, audio_features):
        # 각 모달리티 인코딩
        text_enc = self.text_encoder(text_features).unsqueeze(1)
        audio_enc = self.audio_encoder(audio_features).unsqueeze(1)
        
        # 크로스-모달 어텐션 (텍스트가 음성에 어텐션)
        fused, _ = self.cross_attention(
            query=text_enc, 
            key=audio_enc, 
            value=audio_enc
        )
        
        # 텍스트와 융합 결과 합치기
        combined = torch.cat([
            text_enc.squeeze(1), 
            fused.squeeze(1)
        ], dim=-1)
        
        # 최종 분류
        output = self.classifier(combined)
        return output

# 모델 생성 및 테스트
model = MultimodalSentimentFusion()
text_feat = torch.randn(4, 768)   # 배치 크기 4
audio_feat = torch.randn(4, 96)

output = model(text_feat, audio_feat)
print(f"출력 크기: {output.shape}")  # torch.Size([4, 7])
print(f"예측 감정: {torch.argmax(output, dim=1)}")

emotion_analyzer/
├── app.py              # Flask 서버
├── model.py            # 감정 분석 모델
├── requirements.txt    # 의존성 패키지
└── templates/
    └── index.html      # 프론트엔드

# model.py
from transformers import pipeline
import torch

class EmotionAnalyzer:
    def __init__(self):
        # 다중 감정 분류 모델 로드
        # j-hartmann/emotion-english-distilroberta-base: 7가지 감정 분류
        self.text_classifier = pipeline(
            "text-classification",
            model="j-hartmann/emotion-english-distilroberta-base",
            return_all_scores=True,
            device=0 if torch.cuda.is_available() else -1
        )
        
        # 감정 레이블 한국어 매핑
        self.emotion_map = {
            'anger': {'ko': '분노', 'emoji': '😠', 'color': '#fc8181'},
            'disgust': {'ko': '혐오', 'emoji': '🤢', 'color': '#68d391'},
            'fear': {'ko': '공포', 'emoji': '😨', 'color': '#9f7aea'},
            'joy': {'ko': '기쁨', 'emoji': '😊', 'color': '#f6e05e'},
            'neutral': {'ko': '중립', 'emoji': '😐', 'color': '#a0aec0'},
            'sadness': {'ko': '슬픔', 'emoji': '😢', 'color': '#63b3ed'},
            'surprise': {'ko': '놀라움', 'emoji': '😲', 'color': '#f6ad55'}
        }
    
    def analyze(self, text: str) -> dict:
        if not text.strip():
            return {'error': '텍스트를 입력해주세요'}
        
        # 감정 분석 실행
        results = self.text_classifier(text)[0]
        
        # 결과 정리
        emotions = []
        for item in results:
            label = item['label']
            score = item['score']
            info = self.emotion_map.get(label, {})
            
            emotions.append({
                'label': label,
                'label_ko': info.get('ko', label),
                'emoji': info.get('emoji', '❓'),
                'color': info.get('color', '#gray'),
                'score': round(score * 100, 2)
            })
        
        # 점수 기준 정렬
        emotions.sort(key=lambda x: x['score'], reverse=True)
        
        # 주요 감정
        dominant = emotions[0]
        
        return {
            'text': text,
            'dominant_emotion': dominant,
            'all_emotions': emotions,
            'sentiment': self._get_sentiment(dominant['label'])
        }
    
    def _get_sentiment(self, emotion: str) -> str:
        positive = ['joy', 'surprise']
        negative = ['anger', 'disgust', 'fear', 'sadness']
        
        if emotion in positive:
            return '긍정'
        elif emotion in negative:
            return '부정'
        return '중립'

# 싱글톤 인스턴스
analyzer = EmotionAnalyzer()

# app.py
from flask import Flask, request, jsonify, render_template
from flask_cors import CORS
from model import analyzer
import logging

app = Flask(__name__)
CORS(app)

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/api/analyze', methods=['POST'])
def analyze_emotion():
    try:
        data = request.get_json()
        text = data.get('text', '').strip()
        
        if not text:
            return jsonify({'error': '텍스트를 입력해주세요'}), 400
        
        if len(text) > 512:
            return jsonify({'error': '텍스트가 너무 깁니다 (최대 512자)'}), 400
        
        # 감정 분석
        result = analyzer.analyze(text)
        logger.info(f"분석 완료: {text[:50]}... → {result['dominant_emotion']['label_ko']}")
        
        return jsonify(result)
    
    except Exception as e:
        logger.error(f"오류 발생: {str(e)}")
        return jsonify({'error': '분석 중 오류가 발생했습니다'}), 500

@app.route('/api/batch', methods=['POST'])
def batch_analyze():
    """여러 텍스트 한 번에 분석"""
    data = request.get_json()
    texts = data.get('texts', [])
    
    if len(texts) > 50:
        return jsonify({'error': '최대 50개까지 처리 가능합니다'}), 400
    
    results = [analyzer.analyze(text) for text in texts]
    return jsonify({'results': results})

if __name__ == '__main__':
    app.run(debug=True, host='0.0.0.0', port=5000)

# 감정 분석 모델 성능 평가
from sklearn.metrics import (
    accuracy_score, 
    f1_score, 
    classification_report,
    confusion_matrix
)
import numpy as np

def evaluate_emotion_model(y_true, y_pred, labels):
    """
    감정 분류 모델 종합 평가
    
    Args:
        y_true: 실제 레이블
        y_pred: 예측 레이블
        labels: 감정 레이블 목록
    """
    # 1. 정확도 (Accuracy)
    accuracy = accuracy_score(y_true, y_pred)
    
    # 2. F1 스코어 (Macro: 클래스 불균형 고려)
    f1_macro = f1_score(y_true, y_pred, average='macro')
    f1_weighted = f1_score(y_true, y_pred, average='weighted')
    
    # 3. 상세 분류 보고서
    report = classification_report(y_true, y_pred, target_names=labels)
    
    # 4. 혼동 행렬
    cm = confusion_matrix(y_true, y_pred)
    
    print(f"=" * 50)
    print(f"📊 감정 분류 모델 성능 평가 결과")
    print(f"=" * 50)
    print(f"✅ 정확도 (Accuracy): {accuracy:.4f} ({accuracy*100:.2f}%)")
    print(f"📈 F1 스코어 (Macro): {f1_macro:.4f}")
    print(f"📈 F1 스코어 (Weighted): {f1_weighted:.4f}")
    print(f"\n📋 클래스별 상세 성능:")
    print(report)
    
    # 가장 혼동이 많은 감정 쌍 찾기
    np.fill_diagonal(cm, 0)  # 대각선 제거
    max_idx = np.unravel_index(cm.argmax(), cm.shape)
    print(f"⚠️ 가장 혼동이 많은 쌍: {labels[max_idx[0]]} → {labels[max_idx[1]]} ({cm[max_idx]}건)")
    
    return {
        'accuracy': accuracy,
        'f1_macro': f1_macro,
        'f1_weighted': f1_weighted
    }

# 예시 실행
emotion_labels = ['기쁨', '슬픔', '분노', '공포', '중립']
y_true = [0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2, 3, 4]
y_pred = [0, 1, 2, 3, 4, 0, 2, 2, 3, 4, 0, 1, 2, 1, 4]

metrics = evaluate_emotion_model(y_true, y_pred, emotion_labels)

# GPT-4를 활용한 감정 분석 (Few-shot 방식)
from openai import OpenAI

client = OpenAI()

def analyze_emotion_with_gpt4(text: str) -> dict:
    """GPT-4를 이용한 고급 감정 분석"""
    
    system_prompt = """당신은 감정 분석 전문가입니다.
주어진 텍스트에서 감정을 분석하고 다음 형식으로 응답하세요:
- 주요 감정: [기쁨/슬픔/분노/공포/혐오/놀라움/중립]
- 감정 강도: [1-10]
- 감정 이유: [텍스트에서 감정을 유발한 요소 설명]
- 복합 감정: [있다면 추가 감정 언급]
- 전체 감성: [긍정/부정/중립]"""

    few_shot_examples = [
        {"role": "user", "content": "오늘 드디어 취업했어! 3년 동안 준비했는데 너무 기뻐"},
        {"role": "assistant", "content": "주요 감정: 기쁨\n감정 강도: 9\n감정 이유: 3년간의 노력 끝에 취업 성공이라는 목표 달성\n복합 감정: 안도감, 성취감\n전체 감성: 긍정"},
        {"role": "user", "content": "또 야근이야... 집에 가고 싶다"},
        {"role": "assistant", "content": "주요 감정: 슬픔\n감정 강도: 6\n감정 이유: 반복되는 야근으로 인한 피로와 귀가 욕구\n복합 감정: 피로감, 체념\n전체 감성: 부정"}
    ]
    
    messages = [
        {"role": "system", "content": system_prompt},
        *few_shot_examples,
        {"role": "user", "content": text}
    ]
    
    response = client.chat.completions.create(
        model="gpt-4",
        messages=messages,
        temperature=0.1,  # 일관된 결과를 위해 낮게 설정
        max_tokens=200
    )
    
    result_text = response.choices[0].message.content
    
    # 결과 파싱
    lines = result_text.strip().split('\n')
    result = {}
    for line in lines:
        if ':' in line:
            key, value = line.split(':', 1)
            result[key.strip()] = value.strip()
    
    return result

# 테스트
text = "이 영화 진짜 기대했는데 완전 실망이야. 돈 아깝다."
result = analyze_emotion_with_gpt4(text)
for key, value in result.items():
    print(f"{key}: {value}")

# requirements.txt

# 핵심 딥러닝 프레임워크
torch>=2.0.0
torchvision>=0.15.0
torchaudio>=2.0.0

# Hugging Face 생태계
transformers>=4.35.0
datasets>=2.14.0
tokenizers>=0.14.0
accelerate>=0.24.0

# 한국어 NLP
konlpy>=0.6.0
soynlp>=0.0.493

# 음성 처리
librosa>=0.10.0
soundfile>=0.12.0
pyaudio>=0.2.13

# 데이터 처리
numpy>=1.24.0
pandas>=2.0.0
scikit-learn>=1.3.0

# 시각화
matplotlib>=3.7.0
seaborn>=0.12.0
plotly>=5.17.0

# 웹 서버
flask>=3.0.0
flask-cors>=4.0.0

# 유틸리티
tqdm>=4.66.0
python-dotenv>=1.0.0

# 설치 명령어
pip install -r requirements.txt

# KoNLPy Java 의존성 (macOS/Linux)
# Java 8 이상 필요
brew install java  # macOS
sudo apt-get install default-jdk  # Ubuntu

# MeCab 설치 (더 빠른 한국어 형태소 분석)
# macOS
brew install mecab
pip install python-mecab-ko

# Ubuntu
sudo apt-get install mecab libmecab-dev mecab-ipadic-utf8
pip install python-mecab-ko

# quick_start.py - 5분 만에 감정 분석 시작하기!
from transformers import pipeline

print("🚀 감정 분석 시스템 초기화 중...")

# 방법 1: 영어 감정 분석 (7가지 감정)
emotion_pipe = pipeline(
    "text-classification",
    model="j-hartmann/emotion-english-distilroberta-base",
    return_all_scores=True
)

# 방법 2: 한국어 감성 분석 (긍정/부정)
# 한국어 모델은 Hugging Face Hub에서 검색
# 예: "snunlp/KR-FinBert-SC", "monologg/koelectra-base-finetuned-sentiment"
ko_sentiment = pipeline(
    "text-classification",
    model="monologg/koelectra-base-finetuned-sentiment"
)

print("✅ 초기화 완료!\n")

# 테스트 문장들
test_sentences = [
    "I'm so happy today! Everything is going great!",
    "This is absolutely terrible. I'm so disappointed.",
    "I can't believe what just happened. I'm shocked!"
]

print("📊 영어 감정 분석 결과:")
print("-" * 50)
for sentence in test_sentences:
    results = emotion_pipe(sentence)[0]
    # 가장 높은 점수의 감정
    top_emotion = max(results, key=lambda x: x['score'])
    print(f"텍스트: {sentence[:50]}...")
    print(f"주요 감정: {top_emotion['label']} ({top_emotion['score']:.2%})")
    print()

# 한국어 테스트
ko_sentences = [
    "오늘 정말 기분 최고야! 좋은 일만 생겼어!",
    "이거 진짜 별로다. 돈 아깝고 시간 낭비야.",
    "그냥 평범한 하루였어. 특별한 건 없었어."
]

print("\n📊 한국어 감성 분석 결과:")
print("-" * 50)
for sentence in ko_sentences:
    result = ko_sentiment(sentence)[0]
    label = "긍정 😊" if result['label'] == 'positive' else "부정 😞"
    print(f"텍스트: {sentence}")
    print(f"감성: {label} (확신도: {result['score']:.2%})")
    print()

# 클래스 가중치를 적용한 파인튜닝 예시
import torch
import torch.nn as nn
from transformers import AutoModelForSequenceClassification, Trainer, TrainingArguments
from sklearn.utils.class_weight import compute_class_weight
import numpy as np

# 클래스 가중치 계산
labels = [0, 0, 0, 1, 1, 2, 2, 2, 2, 3]  # 실제 레이블 분포
class_weights = compute_class_weight(
    'balanced', 
    classes=np.unique(labels), 
    y=labels
)
weights_tensor = torch.FloatTensor(class_weights)

# 커스텀 Trainer 클래스 (가중 손실 함수 적용)
class WeightedTrainer(Trainer):
    def compute_loss(self, model, inputs, return_outputs=False):
        labels = inputs.get("labels")
        outputs = model(**inputs)
        logits = outputs.get("logits")
        
        # 가중 크로스 엔트로피 손실
        loss_fct = nn.CrossEntropyLoss(
            weight=weights_tensor.to(logits.device)
        )
        loss = loss_fct(logits.view(-1, self.model.config.num_labels), 
                       labels.view(-1))
        
        return (loss, outputs) if return_outputs else loss

# 학습 설정
training_args = TrainingArguments(
    output_dir="./emotion_model",
    num_train_epochs=5,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=32,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir="./logs",
    evaluation_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
    metric_for_best_model="f1",
    fp16=True,  # GPU 메모리 절약
    dataloader_num_workers=4
)

# 모델 로드 및 파인튜닝
model = AutoModelForSequenceClassification.from_pretrained(
    "klue/roberta-base",
    num_labels=7  # 7가지 감정
)

trainer = WeightedTrainer(
    model=model,
    args=training_args,
    # train_dataset=train_dataset,
    # eval_dataset=eval_dataset,
    # compute_metrics=compute_metrics
)

# trainer.train()  # 실제 학습 실행