Update app.py

app.py

@@ -1,495 +1,507 @@
+"""
+Boolook - 음성 기반 감정 분석 책 추천 (HuggingFace Spaces)
+record_cat.py 알고리즘 기반 업그레이드 버전
+DB 컬럼: isbn, title, author, publisher, content, img_url
+"""
+
 import gradio as gr
 import pandas as pd
 import numpy as np
 import torch
-from transformers import pipeline
-from sentence_transformers import SentenceTransformer, util
+import pickle
 import json
+import csv
+import warnings
+from pathlib import Path
 from datetime import datetime
-import os
+from collections import defaultdict
+from transformers import pipeline as hf_pipeline
+from sentence_transformers import SentenceTransformer, util as sbert_util
+
+warnings.filterwarnings("ignore")
 
-# ===============================
+# ============================================================
 # 설정
-# ===============================
+# ============================================================
+BOOK_DB_PATH     = Path("book_db_final.csv")
+FEEDBACK_PATH    = Path("user_feedback.csv")
+SBERT_CACHE_PATH = Path("book_embeddings.pkl")
+SAMPLE_RATE      = 16000
+MIN_FEEDBACK_FOR_TRAIN = 20
+
 device = 0 if torch.cuda.is_available() else -1
-FEEDBACK_FILE = "feedback_data.jsonl"
-BOOK_DB_FILE = "book_db_final.csv"
 
-# ===============================
-# 모델 로드
-# ===============================
+# ============================================================
+# 모델 로딩
+# ============================================================
 print("🚀 모델 로딩 중...")
 
 try:
-    stt_model = pipeline(
+    stt_model = hf_pipeline(
         "automatic-speech-recognition",
         model="openai/whisper-large-v3-turbo",
-        device=device
+        device=device,
     )
     print("✅ STT 모델 로드 완료")
 except Exception as e:
-    print(f"⚠️ STT 모델 로드 실패: {e}")
+    print(f"⚠️ STT 로드 실패: {e}")
     stt_model = None
 
 try:
-    emotion_model = pipeline(
-        "text-classification",
-        model="monologg/koelectra-base-v3-goemotions",
-        device=device,
-        top_k=None
-    )
-    print("✅ 감정 분석 모델 로드 완료")
+    sbert_model = SentenceTransformer("jhgan/ko-sroberta-multitask")
+    sbert_model.max_seq_length = 384
+    print("✅ SBERT 모델 로드 완료")
 except Exception as e:
-    print(f"⚠️ 감정 분석 모델 로드 실패: {e}")
-    emotion_model = None
+    print(f"⚠️ SBERT 로드 실패: {e}")
+    sbert_model = None
 
 try:
-    sbert_model = SentenceTransformer("jhgan/ko-sroberta-multitask")
-    print("✅ 임베딩 모델 로드 완료")
+    audio_emotion_pipeline = hf_pipeline(
+        "audio-classification",
+        model="superb/wav2vec2-base-superb-er",
+        device=device,
+    )
+    print("✅ 음성 감정 모델 로드 완료")
 except Exception as e:
-    print(f"⚠️ 임베딩 모델 로드 실패: {e}")
-    sbert_model = None
+    print(f"⚠️ 음성 감정 모델 로드 실패: {e}")
+    audio_emotion_pipeline = None
+
+print("✅ 모델 로딩 완료!")
+
+# ============================================================
+# 감정 레이블 & 설명
+# ============================================================
+_EMOTION_DESCS = {
+    "기쁨": "행복하고 즐겁고 유쾌한 기분",
+    "신뢰": "따뜻하고 안정적이며 가족과 우정 같은 유대감",
+    "공포": "무섭고 긴장되며 스릴 있는 공포와 불안",
+    "놀람": "반전과 충격, 예상치 못한 경이로움",
+    "슬픔": "슬프고 외롭고 이별과 상실의 감정",
+    "혐오": "부조리와 불평등, 위선에 대한 비판과 풍자",
+    "분노": "분노와 저항, 투쟁과 갈등",
+    "기대": "성장과 도전, 모험과 희망",
+}
+_EMOTION_LABELS = list(_EMOTION_DESCS.keys())
+_LABEL_EMBS     = sbert_model.encode(list(_EMOTION_DESCS.values()), convert_to_tensor=True) if sbert_model else None
+
+_AUDIO_LABEL_MAP = {"hap": "기쁨", "neu": "신뢰", "sad": "슬픔", "ang": "분노"}
+
+# 한국어 키워드 감정 보정
+_KEYWORD_BOOSTS = {
+    "슬픔": ["슬프", "우울", "눈물", "힘들", "외로"],
+    "분노": ["화나", "짜증", "열받", "빡치", "억울"],
+    "기쁨": ["행복", "좋다", "기쁘", "즐겁", "신나"],
+    "공포": ["무섭", "두렵", "걱정", "불안"],
+    "놀람": ["놀랐", "깜짝", "충격"],
+    "신뢰": ["믿음", "사랑", "따뜻", "고마"],
+    "기대": ["기대", "희망", "설레"],
+}
+
+# ============================================================
+# 세션 피드백 (전역)
+# ============================================================
+class SessionFeedback:
+    def __init__(self):
+        self.accepted_counts = defaultdict(int)
+        self.rejected_counts = defaultdict(int)
+
+    def score_multiplier(self, emotion: str) -> float:
+        acc = self.accepted_counts[emotion]
+        rej = self.rejected_counts[emotion]
+        return max(0.5, 1.0 + (0.1 * acc) - (0.1 * rej))
 
-print("✅ 모든 모델 로딩 완료!")
+_session = SessionFeedback()
 
-# ===============================
-# ��이터 로드
-# ===============================
+# ============================================================
+# 도서 데이터 & 임베딩 로드
+# ============================================================
 def load_book_data():
-    """책 데이터 로드 및 임베딩 생성"""
-    if not os.path.exists(BOOK_DB_FILE):
-        raise FileNotFoundError(f"❌ {BOOK_DB_FILE} 파일이 필요합니다.")
-    
-    df = pd.read_csv(BOOK_DB_FILE)
-    print(f"📚 {len(df)}개의 책 데이터 로드 완료")
-    
-    # 필수 컬럼 확인
-    required_cols = ["title", "emotion"]
-    if not all(col in df.columns for col in required_cols):
-        raise ValueError(f"❌ 필수 컬럼 누락: {required_cols}")
-    
-    # 텍스트 데이터 준비
-    book_texts = df["contents"].fillna(df["title"]).tolist()
-    
-    # 임베딩 생성
-    print("🔄 책 임베딩 생성 중...")
-    book_embeddings = sbert_model.encode(
-        book_texts,
-        convert_to_tensor=True,
-        show_progress_bar=True
-    )
-    print("✅ 임베딩 생성 완료")
-    
+    if not BOOK_DB_PATH.exists():
+        raise FileNotFoundError(f"❌ {BOOK_DB_PATH} 파일이 필요합니다.")
+
+    df = pd.read_csv(BOOK_DB_PATH, encoding="utf-8-sig").fillna("")
+    print(f"📚 {len(df)}권 로드 완료")
+
+    # 임베딩 캐시
+    if SBERT_CACHE_PATH.exists():
+        print("✅ 임베딩 캐시 로드")
+        with open(SBERT_CACHE_PATH, "rb") as f:
+            emb_cache = pickle.load(f)
+    else:
+        emb_cache = {}
+
+    # 캐시에 없는 책만 새로 계산
+    missing = [i for i, row in df.iterrows() if str(row["isbn"]) not in emb_cache]
+    if missing and sbert_model:
+        print(f"⚙️ 신규 임베딩 계산: {len(missing)}권")
+        texts = [
+            (str(df.at[i, "title"]) + " " + str(df.at[i, "content"]))[:500]
+            for i in missing
+        ]
+        vecs = sbert_model.encode(texts, convert_to_tensor=False, show_progress_bar=True)
+        for i, vec in zip(missing, vecs):
+            emb_cache[str(df.at[i, "isbn"])] = vec
+        with open(SBERT_CACHE_PATH, "wb") as f:
+            pickle.dump(emb_cache, f)
+        print("✅ 임베딩 저장 완료")
+
+    # DataFrame 순서에 맞게 임베딩 행렬 구성
+    emb_matrix = np.stack([
+        emb_cache.get(str(row["isbn"]), np.zeros(384))
+        for _, row in df.iterrows()
+    ])
+    book_embeddings = torch.tensor(emb_matrix, dtype=torch.float32)
+
     return df, book_embeddings
 
 df, book_embeddings = load_book_data()
 
-# ===============================
-# 감정 매핑
-# ===============================
-EMOTION_MAP = {
-    "joy": "기쁨",
-    "sadness": "슬픔",
-    "anger": "분노",
-    "fear": "공포",
-    "surprise": "놀람",
-    "disgust": "혐오",
-    "love": "신뢰",
-    "optimism": "기대"
-}
+# ============================================================
+# CatBoost 개인화 모델 (선택적)
+# ============================================================
+_ml_model        = None
+_ml_feature_names = []
 
-EMOTION_LABELS = ["기쁨", "신뢰", "공포", "놀람", "슬픔", "혐오", "분노", "기대"]
-
-# ===============================
-# 피드백 데이터 관리
-# ===============================
-def save_feedback(user_text, emotion, books, feedback_type, book_title=None):
-    """피드백 데이터를 JSONL 형식으로 저장"""
-    feedback_entry = {
-        "timestamp": datetime.now().isoformat(),
-        "user_text": user_text,
-        "detected_emotion": emotion,
-        "recommended_books": [b["title"] for b in books],
-        "feedback_type": feedback_type,
-        "selected_book": book_title
-    }
-    
+def _try_load_catboost():
+    global _ml_model, _ml_feature_names
+    model_path   = Path("catboost_recommender.cbm")
+    encoder_path = Path("feature_encoder.pkl")
     try:
-        with open(FEEDBACK_FILE, "a", encoding="utf-8") as f:
-            f.write(json.dumps(feedback_entry, ensure_ascii=False) + "\n")
+        from catboost import CatBoostClassifier
+        if model_path.exists():
+            _ml_model = CatBoostClassifier()
+            _ml_model.load_model(str(model_path))
+            if encoder_path.exists():
+                with open(encoder_path, "rb") as f:
+                    enc = pickle.load(f)
+            print("✅ CatBoost 모델 로드 완료")
+            return True
     except Exception as e:
-        print(f"⚠️ 피드백 저장 실패: {e}")
+        print(f"⚠️ CatBoost 로드 실패: {e}")
+    return False
 
-def load_feedback_data():
-    """저장된 피드백 데이터 로드"""
-    if not os.path.exists(FEEDBACK_FILE):
-        return []
-    
-    feedback_data = []
+_try_load_catboost()
+
+def _ml_predict(isbn: str, emotion: str, content_len: int) -> float:
+    if _ml_model is None:
+        return 0.5
     try:
-        with open(FEEDBACK_FILE, "r", encoding="utf-8") as f:
-            for line in f:
-                try:
-                    feedback_data.append(json.loads(line.strip()))
-                except json.JSONDecodeError:
-                    continue
-    except Exception as e:
-        print(f"⚠️ 피드백 로드 실패: {e}")
-    
-    return feedback_data
-
-def apply_feedback_learning():
-    """피드백 데이터 기반 추천 가중치 조정"""
-    feedback_data = load_feedback_data()
-    
-    if not feedback_data:
-        return {}
-    
-    weights = {}
-    
-    for entry in feedback_data:
-        emotion = entry.get("detected_emotion")
-        selected_book = entry.get("selected_book")
-        feedback_type = entry.get("feedback_type")
-        
-        if emotion and selected_book:
-            key = (emotion, selected_book)
-            
-            if key not in weights:
-                weights[key] = 0
-            
-            if feedback_type in ["like", "select"]:
-                weights[key] += 1.0
-            elif feedback_type == "dislike":
-                weights[key] -= 0.5
-    
-    return weights
-
-# ===============================
+        X = pd.DataFrame([{
+            "emotion":        emotion,
+            "rank":           1,
+            "input_mode":     "1",
+            "content_length": min(content_len, 500),
+            "has_content":    1 if content_len > 50 else 0,
+        }])
+        return float(_ml_model.predict_proba(X)[0][1])
+    except Exception:
+        return 0.5
+
+# ============================================================
 # 감정 분석
-# ===============================
-def get_emotion_scores(text):
-    """텍스트에서 감정 점수 추출"""
-    if not text or len(text.strip()) == 0:
-        return {emo: 0.0 for emo in EMOTION_LABELS}
-    
-    if emotion_model is None:
-        return {emo: 0.125 for emo in EMOTION_LABELS}
-    
+# ============================================================
+def text_emotion_scores(text: str) -> dict:
+    """SBERT 제로샷 + 키워드 보정 혼합"""
+    scores = {emo: 0.0 for emo in _EMOTION_LABELS}
+
+    if sbert_model and _LABEL_EMBS is not None:
+        user_emb   = sbert_model.encode(text, convert_to_tensor=True)
+        cos_scores = sbert_util.cos_sim(user_emb, _LABEL_EMBS)[0]
+        for i, label in enumerate(_EMOTION_LABELS):
+            scores[label] = cos_scores[i].item()
+
+    # 키워드 보정
+    text_lower = text.lower()
+    for emotion, keywords in _KEYWORD_BOOSTS.items():
+        for kw in keywords:
+            if kw in text_lower:
+                scores[emotion] += 0.15
+                break
+
+    # 정규화
+    total = sum(scores.values())
+    if total > 0:
+        scores = {k: v / total for k, v in scores.items()}
+
+    return scores
+
+def audio_emotion_scores(audio_array: np.ndarray, sr: int) -> dict:
+    """음성 신호 감정 분류"""
+    scores = {emo: 0.0 for emo in _EMOTION_LABELS}
+    if audio_emotion_pipeline is None:
+        return scores
     try:
-        results = emotion_model(text)[0]
-        
-        scores = {emo: 0.0 for emo in EMOTION_LABELS}
-        
-        for r in results:
-            label = r["label"].lower()
-            mapped = EMOTION_MAP.get(label)
-            
+        import scipy.io.wavfile as wav_io
+        tmp = "/tmp/_gradio_voice.wav"
+        wav_io.write(tmp, sr, (audio_array * 32767).astype(np.int16))
+        results = audio_emotion_pipeline(tmp)
+        for item in results:
+            mapped = _AUDIO_LABEL_MAP.get(item["label"])
             if mapped:
-                scores[mapped] += r["score"]
-        
-        # 한국어 키워드 기반 보정
-        text_lower = text.lower()
-        
-        keyword_boosts = {
-            "슬픔": ["슬프", "우울", "눈물", "힘들", "외로"],
-            "분노": ["화나", "짜증", "열받", "빡치", "억울"],
-            "기쁨": ["행복", "좋다", "기쁘", "즐겁", "신나"],
-            "공포": ["무섭", "두렵", "걱정", "불안"],
-            "놀람": ["놀랐", "깜짝", "충격"],
-            "신뢰": ["믿음", "사랑", "따뜻", "고마"],
-            "기대": ["기대", "희망", "설레"]
-        }
-        
-        for emotion, keywords in keyword_boosts.items():
-            for keyword in keywords:
-                if keyword in text_lower:
-                    scores[emotion] += 0.3
-                    break
-        
-        # 정규화
-        total = sum(scores.values())
-        if total > 0:
-            scores = {k: v / total for k, v in scores.items()}
-        
-        return scores
+                scores[mapped] += item["score"]
     except Exception as e:
-        print(f"⚠️ 감정 분석 오류: {e}")
-        return {emo: 0.125 for emo in EMOTION_LABELS}
-
-# ===============================
-# 추천 시스템
-# ===============================
-def recommend_books(user_text, emotion, top_n=3):
-    """감정에 맞는 책 추천 (피드백 학습 반영)"""
-    
-    if sbert_model is None:
+        print(f"⚠️ 음성 감정 분석 오류: {e}")
+    return scores
+
+def fused_emotion(t_scores: dict, a_scores: dict) -> tuple:
+    a_max  = max(a_scores.values()) or 1.0
+    a_norm = {e: v / a_max for e, v in a_scores.items()}
+    combined = {
+        emo: (t_scores[emo] * 0.6) + (a_norm[emo] * 0.4)
+        for emo in _EMOTION_LABELS
+    }
+    return max(combined, key=combined.get), combined
+
+# ============================================================
+# 추천
+# ============================================================
+def get_recommendations(user_text: str, emotion: str, top_n: int = 3) -> list:
+    if sbert_model is None or df.empty:
         return []
-    
+
+    session_w = _session.score_multiplier(emotion)
+    user_vec  = sbert_model.encode(user_text, convert_to_tensor=True)
+    cos_sims  = sbert_util.cos_sim(user_vec, book_embeddings)[0].cpu().numpy()
+
+    # 피드백 가중치
+    fb_weights = _load_feedback_weights()
+
+    results = []
+    for idx, (_, row) in enumerate(df.iterrows()):
+        content_len = len(str(row.get("content", "")))
+        ml_score    = _ml_predict(str(row["isbn"]), emotion, content_len)
+        fb_boost    = fb_weights.get((emotion, str(row["title"])), 0) * 0.1
+        cosine      = float(cos_sims[idx])
+        final       = cosine * 0.6 * session_w + ml_score * 0.4 + fb_boost
+
+        results.append({
+            "isbn":      str(row.get("isbn", "")),
+            "title":     str(row.get("title", "")),
+            "author":    str(row.get("author", "-")),
+            "publisher": str(row.get("publisher", "-")),
+            "content":   str(row.get("content", ""))[:150],
+            "img_url":   str(row.get("img_url", "")),
+            "cosine":    round(cosine, 3),
+            "ml_score":  round(ml_score, 3),
+            "final":     round(final, 3),
+        })
+
+    results.sort(key=lambda x: x["final"], reverse=True)
+    return results[:top_n]
+
+# ============================================================
+# 피드백 저장 & 로드
+# ============================================================
+def _load_feedback_weights() -> dict:
+    if not FEEDBACK_PATH.exists():
+        return {}
+    try:
+        fb_df   = pd.read_csv(FEEDBACK_PATH, encoding="utf-8-sig", on_bad_lines="skip")
+        weights = {}
+        for _, row in fb_df.iterrows():
+            key = (str(row.get("emotion", "")), str(row.get("title", "")))
+            accepted = int(row.get("accepted", 0))
+            weights[key] = weights.get(key, 0) + (1.0 if accepted == 1 else -0.5)
+        return weights
+    except Exception:
+        return {}
+
+def save_feedback_csv(isbn: str, title: str, emotion: str, accepted: int, rank: int):
+    pd.DataFrame([{
+        "timestamp":  datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "isbn":       isbn,
+        "title":      title.replace("\n", " ").replace("\r", " "),
+        "emotion":    emotion,
+        "accepted":   accepted,
+        "input_mode": "gradio",
+        "rank":       rank,
+    }]).to_csv(
+        FEEDBACK_PATH, mode="a", index=False,
+        header=not FEEDBACK_PATH.exists(),
+        encoding="utf-8-sig",
+        quoting=csv.QUOTE_ALL,
+    )
+    if accepted == 1:
+        _session.accepted_counts[emotion] += 1
+    else:
+        _session.rejected_counts[emotion] += 1
+
+def get_feedback_stats() -> str:
+    if not FEEDBACK_PATH.exists():
+        return "📊 아직 피드백 데이터가 없습니다."
     try:
-        pool = df[df["emotion"] == emotion].copy()
-        
-        if pool.empty:
-            pool = df.copy()
-        
-        idxs = pool.index.tolist()
-        pool_embs = book_embeddings[idxs]
-        
-        user_emb = sbert_model.encode(user_text, convert_to_tensor=True)
-        
-        sims = util.cos_sim(user_emb, pool_embs)[0].cpu().numpy()
-        
-        pool["sim"] = sims
-        
-        feedback_weights = apply_feedback_learning()
-        
-        def calculate_final_score(row):
-            base_score = row["sim"]
-            key = (emotion, row["title"])
-            feedback_boost = feedback_weights.get(key, 0) * 0.1
-            return base_score + feedback_boost
-        
-        pool["final_score"] = pool.apply(calculate_final_score, axis=1)
-        pool = pool.sort_values("final_score", ascending=False).head(top_n)
-        
-        books = []
-        for _, row in pool.iterrows():
-            books.append({
-                "title": row["title"],
-                "img_url": row.get("thumbnail", ""),
-                "content": str(row.get("contents", ""))[:150] + "...",
-                "similarity": round(float(row["sim"]), 3),
-                "final_score": round(float(row["final_score"]), 3)
-            })
-        
-        return books
+        fb_df = pd.read_csv(FEEDBACK_PATH, encoding="utf-8-sig", on_bad_lines="skip")
+        total = len(fb_df)
+        if total == 0:
+            return "📊 아직 피드백 데이터가 없습니다."
+
+        emo_counts = fb_df.groupby("emotion")["accepted"].agg(["count", "sum"])
+        lines = [f"**총 피드백: {total}건**\n"]
+        for emo, row_s in emo_counts.iterrows():
+            rate = int(row_s["sum"]) / int(row_s["count"]) * 100
+            lines.append(f"- {emo}: {int(row_s['count'])}건 (수락률 {rate:.0f}%)")
+        return "\n".join(lines)
     except Exception as e:
-        print(f"⚠️ 추천 오류: {e}")
-        return []
+        return f"⚠️ 통계 로드 실패: {e}"
 
-# ===============================
+# ============================================================
 # 메인 처리 함수
-# ===============================
+# ============================================================
 def process_voice(audio_input):
-    """음성 입력 처리 및 책 추천"""
-    
-    empty_result = {
-        "status": "error",
-        "user_input": "",
-        "emotion_label": "",
-        "emotion_score": 0.0,
-        "books": [],
-        "message": ""
-    }
-    
+    """Gradio 음성 입력 → STT → 감정 분석 → 추천"""
     if audio_input is None:
-        empty_result["message"] = "🎤 음성을 녹음해주세요."
-        return empty_result
-    
+        return "🎤 음성을 녹음해주세요.", "", "", [], ""
+
     if stt_model is None:
-        empty_result["message"] = "❌ STT 모델이 로드되지 않았습니다."
-        return empty_result
-    
+        return "❌ STT 모델이 로드되지 않았습니다.", "", "", [], ""
+
     try:
         sr, y = audio_input
-        y = y.astype(np.float32)
-        
-        max_val = np.max(np.abs(y))
-        if max_val > 0:
-            y = y / max_val
-        
+        y     = y.astype(np.float32)
+        max_v = np.max(np.abs(y))
+        if max_v > 0:
+            y = y / max_v
+
+        # STT
         stt_result = stt_model({"sampling_rate": sr, "raw": y})
-        final_text = stt_result["text"].strip()
-        
-        if not final_text:
-            empty_result["message"] = "❌ 음성이 인식되지 않았습니다."
-            return empty_result
-        
-        scores = get_emotion_scores(final_text)
-        top_emotions = sorted(scores.items(), key=lambda x: x[1], reverse=True)[:3]
-        best_emotion, best_score = top_emotions[0]
-        
-        books = recommend_books(final_text, best_emotion, top_n=3)
-        
-        result = {
-            "status": "success",
-            "user_input": final_text,
-            "emotion_label": best_emotion,
-            "emotion_score": round(best_score, 3),
-            "books": books,
-            "message": f"✨ '{best_emotion}' 감정에 맞는 책을 추천해드립니다."
-        }
-        
-        save_feedback(final_text, best_emotion, books, "recommend")
-        
-        return result
-        
+        user_text  = stt_result["text"].strip()
+
+        if not user_text:
+            return "❌ 음성이 인식되지 않았습니다.", "", "", [], ""
+
+        # 감정 분석 (텍스트 + 음성 융합)
+        t_scores            = text_emotion_scores(user_text)
+        a_scores            = audio_emotion_scores(y, sr)
+        top_label, combined = fused_emotion(t_scores, a_scores)
+        top3                = sorted(combined.items(), key=lambda x: x[1], reverse=True)[:3]
+        emotion_str         = " | ".join(f"{e} {p:.2f}" for e, p in top3)
+
+        # 추천
+        books = get_recommendations(user_text, top_label, top_n=3)
+
+        # 추천 결과 마크다운
+        books_md = _render_books_md(books, top_label)
+
+        return user_text, top_label, emotion_str, books, books_md
+
+    except Exception as e:
+        return f"❌ 오류: {e}", "", "", [], ""
+
+
+def _render_books_md(books: list, emotion: str) -> str:
+    if not books:
+        return "추천할 책을 찾지 못했습니다."
+
+    md = f"### 📖 [{emotion}] 감정에 어울리는 책\n\n"
+    for i, b in enumerate(books, 1):
+        ml_icon = "🔥" if b["ml_score"] > 0.7 else ("✨" if b["ml_score"] > 0.5 else "💡")
+        md += f"**{ml_icon} {i}. {b['title']}**\n"
+        md += f"- 저자: {b['author']} | 출판사: {b['publisher']}\n"
+        md += f"- {b['content']}...\n"
+        md += f"- 유사도: `{b['cosine']}` | ML: `{b['ml_score']}` | 최종: `{b['final']}`\n"
+        if b["img_url"]:
+            md += f"- 🖼️ [표지 보기]({b['img_url']})\n"
+        md += "\n---\n"
+    return md
+
+
+def on_feedback(books_state: list, emotion: str, rank_str: str, liked: bool):
+    """좋아요/싫어요 버튼 클릭"""
+    try:
+        rank = int(rank_str) - 1
+        if not books_state or rank < 0 or rank >= len(books_state):
+            return "⚠️ 책을 먼저 추천받아주세요."
+        book     = books_state[rank]
+        accepted = 1 if liked else 0
+        save_feedback_csv(book["isbn"], book["title"], emotion, accepted, rank + 1)
+        icon = "👍" if liked else "👎"
+        return f"{icon} '{book['title']}' 피드백이 저장되었습니다. 학습에 반영됩니다!"
     except Exception as e:
-        empty_result["message"] = f"❌ 오류 발생: {str(e)}"
-        print(f"처리 오류: {e}")
-        return empty_result
-
-def record_book_selection(user_text, emotion, books, selected_title):
-    """사용자가 책을 선택했을 때 피드백 저장"""
-    if selected_title and user_text:
-        save_feedback(user_text, emotion, books, "select", selected_title)
-        return f"✅ '{selected_title}' 선택이 기록되었습니다. 학습에 반영됩니다!"
-    return "⚠️ 선택 기록 실패"
-
-# ===============================
+        return f"⚠️ 피드백 저장 실패: {e}"
+
+# ============================================================
 # Gradio UI
-# ===============================
+# ============================================================
 custom_css = """
-.feedback-section {
-    background-color: #f0f8ff;
-    padding: 20px;
-    border-radius: 10px;
-}
+.feedback-row { background: #f0f8ff; padding: 12px; border-radius: 8px; }
+.book-card    { border: 1px solid #ddd; border-radius: 8px; padding: 12px; margin: 8px 0; }
 """
 
-with gr.Blocks(theme=gr.themes.Soft(), css=custom_css) as demo:
-    
-    gr.Markdown(
-        """
-        # 📚 Boolook: 음성 기반 감정 분석 책 추천
-        
-        당신의 감정을 말로 표현하면, AI가 분석하여 딱 맞는 책을 추천해드립니다.
-        
-        🎤 **사용 방법:**
-        1. 마이크 버튼을 눌러 현재 감정을 표현해보세요
-        2. "분석하기" 버튼을 클릭하세요
-        3. 추천받은 책 중 마음에 드는 책을 선택해주세요 (선택 시 학습됩니다!)
-        """
-    )
-    
-    state_text = gr.State("")
+with gr.Blocks(theme=gr.themes.Soft(), css=custom_css, title="Boolook 📚") as demo:
+
+    gr.Markdown("""
+    # 📚 Boolook — 음성 기반 감정 분석 책 추천
+    당신의 감정을 말로 표현하면, AI가 분석하여 딱 맞는 책을 추천해드립니다.
+
+    🎤 **사용 방법:**
+    1. 마이크 버튼을 눌러 현재 감정을 표현하세요
+    2. "분석하기" 버튼을 클릭하세요
+    3. 추천된 책에 👍 / 👎 피드백을 주세요 (학습에 반영됩니다!)
+    """)
+
+    # 상태 저장
+    state_books   = gr.State([])
     state_emotion = gr.State("")
-    state_books = gr.State([])
-    
+
     with gr.Row():
         with gr.Column(scale=1):
             gr.Markdown("### 🎤 음성 입력")
             audio_in = gr.Audio(
                 label="마이크로 감정 표현하기",
                 sources=["microphone"],
-                type="numpy"
-            )
-            
-            analyze_btn = gr.Button(
-                "🔍 분석하기",
-                variant="primary",
-                size="lg"
-            )
-            
-            gr.Markdown(
-                """
-                **💡 팁:**
-                - "오늘 너무 슬퍼요"
-                - "행복한 기분이에요"
-                - "화가 나는 일이 있었어요"
-                """
+                type="numpy",
             )
-            
+            analyze_btn = gr.Button("🔍 분석하기", variant="primary", size="lg")
+            gr.Markdown("""
+            **💡 예시:**
+            - "오늘 너무 슬퍼요"
+            - "행복한 기분이에요"
+            - "화가 나는 일이 있었어요"
+            """)
+
         with gr.Column(scale=1):
             gr.Markdown("### 📊 분석 결과")
-            
-            output_json = gr.JSON(
-                label="상세 결과",
-                visible=True
-            )
-    
-    with gr.Row():
-        gr.Markdown("### 📖 추천 도서 목록")
-    
-    with gr.Row():
-        book_display = gr.Markdown("분석 후 추천 도서가 표시됩니다.")
-    
-    with gr.Accordion("💬 책 선택 피드백 (학습에 반영됩니다)", open=True, elem_classes="feedback-section"):
-        gr.Markdown("마음에 드는 책이 있다면 제목을 입력하고 기록해주세요!")
-        
+            out_text    = gr.Textbox(label="인식된 텍스트", interactive=False)
+            out_emotion = gr.Textbox(label="감지된 주감정",  interactive=False)
+            out_emo_all = gr.Textbox(label="감정 분포 TOP3", interactive=False)
+
+    gr.Markdown("### 📖 추천 도서")
+    out_books_md = gr.Markdown("분석 후 추천 도서가 표시됩니다.")
+
+    with gr.Accordion("💬 피드백 (학습에 반영)", open=True, elem_classes="feedback-row"):
+        gr.Markdown("추천받은 책 번호를 선택하고 👍 / 👎 로 평가해주세요!")
         with gr.Row():
-            selected_book_input = gr.Textbox(
-                label="선택한 책 제목",
-                placeholder="예: 1984",
-                scale=3
-            )
-            feedback_btn = gr.Button("✅ 선택 기록", scale=1)
-        
-        feedback_result = gr.Textbox(label="피드백 결과", interactive=False)
-    
+            rank_radio   = gr.Radio(["1", "2", "3"], label="책 번호", value="1")
+            like_btn     = gr.Button("👍 좋아요", variant="primary")
+            dislike_btn  = gr.Button("👎 싫어요",  variant="secondary")
+        feedback_out = gr.Textbox(label="피드��� 결과", interactive=False)
+
     with gr.Accordion("📈 피드백 통계", open=False):
-        stats_display = gr.Markdown("통계를 확인하려면 새로고침 버튼을 누르세요.")
-        
-        def show_stats():
-            feedback_data = load_feedback_data()
-            total = len(feedback_data)
-            
-            if total == 0:
-                return "📊 아직 피드백 데이터가 없습니다."
-            
-            emotion_counts = {}
-            for entry in feedback_data:
-                emo = entry.get("detected_emotion", "Unknown")
-                emotion_counts[emo] = emotion_counts.get(emo, 0) + 1
-            
-            stats_text = f"**총 피드백 수:** {total}\n\n"
-            stats_text += "**감정별 분석 요청:**\n\n"
-            for emo, count in sorted(emotion_counts.items(), key=lambda x: x[1], reverse=True):
-                stats_text += f"- {emo}: {count}회\n"
-            
-            return stats_text
-        
+        stats_md          = gr.Markdown("새로고침을 눌러 확인하세요.")
         refresh_stats_btn = gr.Button("🔄 통계 새로고침")
-        refresh_stats_btn.click(fn=show_stats, outputs=stats_display)
-    
-    def update_ui(result):
-        if result["status"] == "success":
-            books_md = f"**{result['message']}**\n\n"
-            
-            if result["books"]:
-                for i, book in enumerate(result["books"], 1):
-                    books_md += f"""
-### {i}. {book['title']}
-- **유사도 점수:** {book['similarity']}
-- **최종 점수:** {book['final_score']} (피드백 반영)
-- **줄거리:** {book['content']}
-
----
-"""
-            else:
-                books_md += "추천할 책을 찾지 못했습니다."
-            
-            return (
-                result,
-                books_md,
-                result["user_input"],
-                result["emotion_label"],
-                result["books"]
-            )
-        else:
-            return (
-                result,
-                f"⚠️ {result.get('message', '오류 발생')}",
-                "",
-                "",
-                []
-            )
-    
+        refresh_stats_btn.click(fn=get_feedback_stats, outputs=stats_md)
+
+    # ── 이벤트 연결 ──
+    def run_analysis(audio):
+        user_text, emotion, emo_all, books, books_md = process_voice(audio)
+        return user_text, emotion, emo_all, books, emotion, books_md
+
     analyze_btn.click(
-        fn=process_voice,
+        fn=run_analysis,
         inputs=audio_in,
-        outputs=output_json
-    ).then(
-        fn=update_ui,
-        inputs=output_json,
-        outputs=[output_json, book_display, state_text, state_emotion, state_books]
+        outputs=[out_text, out_emotion, out_emo_all, state_books, state_emotion, out_books_md],
+    )
+
+    like_btn.click(
+        fn=lambda books, emo, rank: on_feedback(books, emo, rank, liked=True),
+        inputs=[state_books, state_emotion, rank_radio],
+        outputs=feedback_out,
     )
-    
-    feedback_btn.click(
-        fn=record_book_selection,
-        inputs=[state_text, state_emotion, state_books, selected_book_input],
-        outputs=feedback_result
+    dislike_btn.click(
+        fn=lambda books, emo, rank: on_feedback(books, emo, rank, liked=False),
+        inputs=[state_books, state_emotion, rank_radio],
+        outputs=feedback_out,
     )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()