Merge pull request #10 from 2025-Graduation-Design/new

new -> main

Author: duehee

app/diary/models.py

@@ -1,4 +1,4 @@
-from sqlalchemy import Column, Integer, ForeignKey, Text, Float, DateTime, JSON
+from sqlalchemy import Column, Integer, ForeignKey, Text, Float, DateTime, JSON, String
 from sqlalchemy.orm import relationship
 from datetime import datetime
 from app.database import Base
@@ -16,14 +16,31 @@ class Diary(Base):
     created_at = Column(DateTime, default=datetime.utcnow, nullable=False)
     updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
 
-    # ✅ 클래스명을 정확히 사용 (User, EmotionType)
     user = relationship("User", back_populates="diaries")
     emotion = relationship(EmotionType, back_populates="diaries")
+    recommended_songs = relationship("RecommendedSong", back_populates="diary", cascade="all, delete-orphan")
 
 
 class diaryEmbedding(Base):
     __tablename__ = "diaryEmbedding"
 
     id = Column(Integer, primary_key=True, autoincrement=True)
     diary_id = Column(Integer, nullable=False)
-    embedding = Column(JSON, nullable=False)
+    embedding = Column(JSON, nullable=False)
+
+
+class RecommendedSong(Base):
+    __tablename__ = "recommendedSongs"
+
+    id = Column(Integer, primary_key=True)
+    diary_id = Column(Integer, ForeignKey('diary.id'), nullable=False)
+    song_id = Column(Integer, nullable=False)
+    song_name = Column(String(256))
+    artist = Column(JSON)
+    genre = Column(String(64))
+    album_image = Column(String(512))
+    best_lyric = Column(Text)
+    similarity_score = Column(Float)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+    diary = relationship("Diary", back_populates="recommended_songs")

app/diary/router.py

@@ -6,8 +6,8 @@
 from app.emotion.router import predict_emotion
 from app.statistics.models import EmotionStatistics
 from app.user.auth import get_current_user
-from app.diary.models import Diary
-from app.diary.schemas import DiaryCreateRequest, DiaryUpdateRequest, DiaryResponse, DiaryCountResponse
+from app.diary.models import Diary, RecommendedSong
+from app.diary.schemas import DiaryCreateRequest, DiaryUpdateRequest, DiaryResponse, DiaryCountResponse, SongResponse
 from app.user.models import User
 from app.embedding.models import kobert, save_diary_embedding, split_sentences, get_user_preferred_genres, \
     get_songs_by_genre, get_song_embeddings, calculate_similarity
@@ -18,15 +18,13 @@
 import torch
 import numpy as np
 import heapq
-import torch.nn.functional as F
 from datetime import datetime
 
 router = APIRouter()
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# 📝 일기 작성 API
 @router.post("", response_model=DiaryResponse, status_code=201, summary="일기 작성 & 노래 추천",
              description="일기를 작성하면 자동으로 임베딩을 진행하고, 사용자의 선호 장르 내에서 가장 유사한 노래를 추천합니다.")
 async def create_diary(
@@ -305,6 +303,32 @@ async def create_diary_with_music_recommend_top3(
 
         save_diary_embedding(session, new_diary.id, combined_embedding)
 
+        recommended_songs = [
+            {
+                "song_id": match["song_id"],
+                "song_name": match["metadata"]["song_name"],
+                "best_lyric": " ".join(match["lyric_chunk"]),
+                "similarity_score": round(float(sim), 4),
+                "album_image": match["metadata"]["album_image"],
+                "artist": match["metadata"]["artist"],
+                "genre": match["metadata"]["genre"]
+            }
+            for sim, match in top_3
+        ]
+
+        for song_data in recommended_songs:
+            new_song = RecommendedSong(
+                diary_id=new_diary.id,
+                song_id=song_data["song_id"],  # MongoDB ID 문자열 변환
+                song_name=song_data["song_name"],
+                artist=song_data["artist"],
+                genre=song_data["genre"],
+                album_image=song_data["album_image"],
+                best_lyric=song_data["best_lyric"],
+                similarity_score=song_data["similarity_score"]
+            )
+            session.add(new_song)
+
         # 9-1) 감정 통계 업데이트 또는 추가
         existing_stat = session.query(EmotionStatistics).filter(
             EmotionStatistics.user_id == current_user.id,
@@ -327,20 +351,9 @@ async def create_diary_with_music_recommend_top3(
             )
             session.add(new_stat)
 
-        # 10) 응답 구성
-        recommended_songs = [
-            {
-                "song_id": match["song_id"],
-                "song_name": match["metadata"]["song_name"],
-                "best_lyric": " ".join(match["lyric_chunk"]),
-                "similarity_score": round(float(sim), 4),
-                "album_image": match["metadata"]["album_image"],
-                "artist": match["metadata"]["artist"],
-                "genre": match["metadata"]["genre"]
-            }
-            for sim, match in top_3
-        ]
+        session.commit()
 
+        # 10) 응답 구성
         response_data = {
             "id": new_diary.id,
             "user_id": new_diary.user_id,
@@ -349,7 +362,9 @@ async def create_diary_with_music_recommend_top3(
             "confidence": confidence_full,
             "created_at": new_diary.created_at,
             "updated_at": new_diary.updated_at,
-            "recommended_songs": recommended_songs
+            "recommended_songs": recommended_songs,
+            "top_emotions": [{"emotion_id": emo_id, "score": round(score, 4)}
+                            for emo_id, score in sorted(emotion_vote_counter.items(), key=lambda x: -x[1])[:3]]
         }
 
         logger.info("추천 결과: %s", json.dumps(response_data, indent=2, ensure_ascii=False, default=str))
@@ -374,6 +389,33 @@ def get_diary(
 
     return diary
 
+@router.get("/{diary_id}/recommended-songs", response_model=list[SongResponse],
+            summary="추천 노래 조회",
+            description="특정 일기에 대한 추천 노래 리스트를 조회합니다.")
+def get_recommended_songs_by_diary(
+    diary_id: int,
+    current_user: User = Depends(get_current_user),
+    db: Session = Depends(get_db)
+):
+    # 1. 해당 일기가 유저의 것인지 검증
+    diary = db.query(Diary).filter(
+        Diary.id == diary_id,
+        Diary.user_id == current_user.id
+    ).first()
+
+    if not diary:
+        raise HTTPException(status_code=404, detail="일기를 찾을 수 없습니다.")
+
+    # 2. 추천곡 조회
+    songs = db.query(RecommendedSong).filter(
+        RecommendedSong.diary_id == diary_id
+    ).order_by(RecommendedSong.similarity_score.desc()).all()
+
+    if not songs:
+        raise HTTPException(status_code=404, detail="추천된 노래가 없습니다.")
+
+    return songs
+
 @router.get("", response_model=List[DiaryResponse],
             summary="내 일기 목록 조회",
             description="로그인한 사용자가 작성한 모든 일기를 조회합니다.")

app/diary/schemas.py

@@ -2,6 +2,10 @@
 from datetime import datetime
 from typing import Optional
 
+class EmotionScore(BaseModel):
+    emotion_id: int
+    score: float
+
 # Request
 class DiaryCreateRequest(BaseModel):
     content: str
@@ -10,12 +14,26 @@ class DiaryUpdateRequest(BaseModel):
     content: Optional[str] = None
 
 # Response
+class SongResponse(BaseModel):
+    song_id: int  # MongoDB _id → 문자열 변환
+    song_name: str
+    artist: list[str]
+    genre: str
+    album_image: str
+    best_lyric: str
+    similarity_score: float
+
+    class Config:
+        allow_population_by_field_name = True
+
 class DiaryResponse(BaseModel):
     id: int
     user_id: int
     content: str
     emotiontype_id: Optional[int] = None
     confidence: Optional[float] = None
+    recommended_songs: list[SongResponse]
+    top_emotions: list[EmotionScore] = None
     created_at: datetime
     updated_at: datetime
 

app/embedding/router.py

@@ -42,16 +42,22 @@ async def embed_songs(
             try:
                 embeddings = [
                     kobert.get_embedding(line)
-                    for line in lyrics if line.strip()
+                    for line in lyrics
+                    if line.strip() and len(line.strip()) >= 15
                 ]
+
+                if not embeddings:
+                    logger.info(f"스킵됨 (song_id={song_id}): 임베딩 가능한 가사가 없음")
+                    continue
+
                 save_song_embedding(db, song_id, embeddings)
                 processed_songs.append({"song_id": song_id, "status": "embedded"})
             except Exception as e:
                 logger.error(f"임베딩 실패 (song_id={song_id}): {e}")
                 continue
 
         db.commit()
-        time.sleep(3)  # 한 배치 끝나고 쿨다운
+        time.sleep(2)  # 한 배치 끝나고 쿨다운
 
     return {
         "total_songs": len(songs),

app/emotion/models.py

@@ -1,6 +1,6 @@
 import torch
-import torch.nn as nn
-from transformers import BertModel, BertTokenizer, AutoTokenizer, AutoModel
+from transformers import BertForSequenceClassification
+from kobert_tokenizer import KoBERTTokenizer
 
 from sqlalchemy import Column, Integer, ForeignKey, String
 from sqlalchemy.orm import relationship
@@ -30,24 +30,9 @@ class EmotionType(Base):
     quadrant = Column(Integer, nullable=False)
     related_emotion_id = Column(Integer, ForeignKey("emotionType.id", ondelete="SET NULL"), nullable=True)
 
-    # ✅ 관계 명칭을 `diaries`로 변경
     diaries = relationship("Diary", back_populates="emotion")
 
-class EmotionClassifier(nn.Module):
-    def __init__(self, num_classes=8):
-        super(EmotionClassifier, self).__init__()
-        self.bert = AutoModel.from_pretrained("skt/kobert-base-v1")
-        self.dropout = nn.Dropout(0.1)
-        self.classifier = nn.Linear(self.bert.config.hidden_size, num_classes)
-
-    def forward(self, input_ids, attention_mask):
-        outputs = self.bert(input_ids=input_ids, attention_mask=attention_mask)
-        pooled = outputs.pooler_output
-        return self.classifier(self.dropout(pooled))
-
-tokenizer = AutoTokenizer.from_pretrained("skt/kobert-base-v1")
-
-model = EmotionClassifier(num_classes=len(emotion_labels))
-state_dict = torch.load("app/emotion/best_model(1st).pt", map_location=torch.device("cpu"))
-model.load_state_dict(state_dict)
+tokenizer = KoBERTTokenizer.from_pretrained("skt/kobert-base-v1")
+model = BertForSequenceClassification.from_pretrained("skt/kobert-base-v1", num_labels=8)
+model.load_state_dict(torch.load("app/emotion/best_model(7th).pt", map_location="cpu"))
 model.eval()

app/emotion/router.py

@@ -4,20 +4,21 @@
 
 logger = logging.getLogger(__name__)
 
-
 def predict_emotion(text: str):
-    inputs = tokenizer(text, return_tensors='pt', truncation=True, padding=True)
+    inputs = tokenizer(
+        text,
+        return_tensors='pt',
+        truncation=True,
+        padding=True,
+        max_length=256
+    )
     with torch.no_grad():
         outputs = model(
             input_ids=inputs["input_ids"],
             attention_mask=inputs["attention_mask"]
         )
-        # outputs가 Tensor일 경우 그냥 사용
-        if isinstance(outputs, tuple) or isinstance(outputs, list):
-            logits = outputs[0]
-        else:
-            logits = outputs
 
+        logits = outputs.logits
         probs = torch.softmax(logits, dim=1)
         pred_index = torch.argmax(probs, dim=1).item()
 

app/emotion/schemas.py

@@ -13,10 +13,6 @@ def get_all_genres(db: Session = Depends(get_db)):
 
 @router.post("/new", summary="장르 추가", description="현재 DB에 있는 음악 장르를 추가합니다.")
 async def add_genres_from_mongodb(mongodb=Depends(get_mongodb), db: Session = Depends(get_db)):
-    """
-    MongoDB에서 'genre' 컬럼을 가져와 MySQL의 Genre 테이블에 추가
-    (중복 제거 후 추가)
-    """
     mongo_genres = await mongodb["song_meta"].distinct("genre")
     genre_set = set()
 

app/genre/router.py

@@ -1,4 +1,5 @@
 from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
 
 from app.user.router import router as user_router
 from app.diary.router import router as diary_router
@@ -18,6 +19,14 @@
 app.include_router(embedding_router, prefix="/embedding", tags=["embedding"])
 app.include_router(statistics_router, prefix="/statistics", tags=["statistics"])
 
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # 모든 도메인 허용 (개발용)
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
 @app.get("/")
 def read_root():
-    return {"message": "Hello, Melog API!"}
+    return {"message": "멜로그 시작 화면에 뜰 메세지에요~"}

app/main.py

@@ -7,10 +7,10 @@ def transactional_session(db: Session):
     Spring Boot @Transactional처럼 사용할 수 있는 컨텍스트 매니저
     """
     try:
-        yield db  # ✅ 트랜잭션 시작
-        db.commit()  # ✅ 정상 실행 시 커밋
+        yield db
+        db.commit()
     except Exception as e:
-        db.rollback()  # 🚨 예외 발생 시 롤백
+        db.rollback()
         raise e
     finally:
-        db.close()  # ✅ 세션 닫기
+        db.close()