Initial commit with final, clean project files

.gitattributes

@@ -0,0 +1,4 @@
+korean-emotion-classifier-final/model.safetensors filter=lfs diff=lfs merge=lfs -text
+*safetensores filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text

.github/workflows/sync-to-hub.yml

@@ -0,0 +1,31 @@
+name: Sync to Hugging Face hub # 이 Action의 이름
+
+on:
+  push:
+    branches: [main] # GitHub의 'main' 브랜치에 push 이벤트가 발생할 때마다 실행됩니다.
+
+jobs:
+  sync-to-hub:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          lfs: true
+
+      - name: Push to hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }} # 1단계에서 GitHub에 저장한 HF_TOKEN 값을 가져옵니다.
+        run: |
+          # 사용자 이름(koons)과 Space 이름(emotion-chatbot)이 포함된 주소를 설정합니다.
+          # git-lfs를 사용하는 경우를 대비해 사용자 정보를 설정합니다.
+          git config --global user.email "[email protected]"
+          git config --global user.name "Hugging Face"
+          
+          # 'huggingface'라는 이름으로 원격 저장소 주소를 추가합니다.
+          # 주소 형식: https://[사용자이름]:[토큰]@[Hugging Face 주소]
+          git remote add huggingface https://koons:${HF_TOKEN}@huggingface.co/spaces/koons/emotion-chatbot
+          
+          # 현재 로컬의 HEAD(최신 커밋)를 huggingface 원격 저장소의 main 브랜치로 강제 푸시합니다.
+          # -f 옵션은 Space의 기존 기록을 덮어쓰므로, GitHub를 기준으로 항상 최신 상태를 유지합니다.
+          git push huggingface HEAD:main -f

.gitignore

@@ -0,0 +1,19 @@
+# 가상환경 폴더
+venv/
+.venv/
+
+# 파이썬 캐시 파일
+__pycache__/
+*.pyc
+
+# VS Code 설정 폴더
+.vscode/
+
+# 훈련 로그 폴더
+logs/
+
+# 훈련된 모델이 저장된 폴더
+results/
+
+# 기타 운영체제 파일
+.DS_Store

Dockerfile

@@ -0,0 +1,18 @@
+# 1. 베이스 이미지 선택 (파이썬 3.10 버전)
+FROM python:3.10-slim
+
+# 2. 작업 폴더 설정
+WORKDIR /app
+
+# 3. 필요한 라이브러리 설치
+COPY requirements.txt requirements.txt
+RUN pip install --no-cache-dir -r requirements.txt
+
+# 4. 프로젝트 전체 코드 복사
+COPY . .
+
+# 5. Hugging Face Spaces가 사용할 포트(7860) 열기
+EXPOSE 7860
+
+# 6. 최종 실행 명령어 (gunicorn으로 src 폴더 안의 app.py를 실행)
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "src.app:app"]

README.md

@@ -0,0 +1,111 @@
+# 🤖 일기 기반 감정 분석 및 콘텐츠 추천 웹 애플리케이션
+
+> 사용자의 일기 텍스트를 AI로 분석하여 감정을 파악하고, '감정 수용' 또는 '기분 전환'이라는 두 가지 선택지에 따라 맞춤형 콘텐츠(영화, 음악, 책)를 추천해주는 웹 기반 서비스입니다.
+
+<br>
+
+![Python](https://img.shields.io/badge/Python-3.10-3776AB?style=for-the-badge&logo=python)
+![PyTorch](https://img.shields.io/badge/PyTorch-%23EE4C2C.svg?style=for-the-badge&logo=PyTorch&logoColor=white)
+![Flask](https://img.shields.io/badge/Flask-000000?style=for-the-badge&logo=flask&logoColor=white)
+![Hugging Face](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Transformers-yellow?style=for-the-badge)
+
+<br>
+
+## ✨ 주요 기능 (Key Features)
+
+* **AI 기반 감정 분석:** Hugging Face의 `klue/roberta-base` 모델을 AI Hub의 '감성대화 말뭉치' 데이터셋으로 미세 조정(Fine-tuning)하여, 한국어 텍스트에 대한 높은 정확도의 감정 예측을 수행합니다.
+* **상황별 맞춤 추천:** 분석된 감정에 대해 '감정을 깊이 느끼고 싶을 때(수용)'와 '감정에서 벗어나고 싶을 때(전환)'라는 두 가지 선택지를 제공하여, 사용자의 현재 니즈에 맞는 차별화된 콘텐츠를 추천합니다.
+* **다이어리 히스토리:** 사용자가 작성한 일기와 AI의 분석 결과를 웹 브라우저의 `localStorage`에 저장하여, 언제든 과거의 기록을 다시 확인하고 감정의 흐름을 파악할 수 있습니다.
+* **사용자 친화적 웹 인터페이스:** Flask 기반의 웹 서버와 동적인 JavaScript를 통해, 누구나 쉽게 자신의 감정을 기록하고 추천을 받을 수 있는 직관적인 UI/UX를 제공합니다.
+
+<br>
+
+## 🖥️ 프로젝트 데모 (Demo)
+
+임시 홈페이지(https://kootaeng2.github.io/Emotion_Chatbot_project/templates/emotion_homepage.html)
+
+<br>
+
+## ⚙️ 기술 스택 (Tech Stack)
+
+| 구분 | 기술 |
+| :--- | :--- |
+| **Backend** | Flask |
+| **Frontend**| HTML, CSS, JavaScript |
+| **AI / Data**| Python 3.10, PyTorch, Hugging Face Transformers, Scikit-learn, Pandas |
+| **AI Model**| `klue/roberta-base` (Fine-tuned) |
+
+<br>
+
+## 📂 폴더 구조 (Folder Structure)
+
+```
+sentiment_analysis_project/
+├── src/                 
+│   ├── app.py           # 웹 서버 실행 파일
+│   ├── chatbot.py       # 터미널 챗봇 실행 파일
+│   ├── emotion_engine.py  # 감정 분석 엔진 모듈
+│   └── recommender.py     # 추천 로직 모듈
+├── scripts/             
+│   └── train_model.py     # AI 모델 훈련 스크립트
+├── notebooks/           
+│   └── 1_explore_data.py  # 데이터 탐색 및 시각화용 노트북
+├── data/                  # 원본 데이터셋
+├── results/               # 훈련된 모델 파일 (Git 미포함)
+├── templates/             # HTML 파일
+├── static/                # CSS, 클라이언트 JS 파일
+├── .gitignore             # Git 무시 파일 목록
+├── README.md              # 프로젝트 설명서
+└── requirements.txt       # 필수 라이브러리 목록
+```
+<br>
+
+## 🚀 설치 및 실행 방법 (Installation & Run)
+
+**1. 프로젝트 복제 (Clone)**
+```bash
+git clone [https://github.com/kootaeng2/Emotion_Chatbot_project.git](https://github.com/kootaeng2/Emotion_Chatbot_project.git)
+cd Emotion_Chatbot_project
+```
+
+**2. 가상환경 생성 및 활성화 (Python 3.10 기준)**
+```bash
+# Python 3.10 버전을 지정하여 가상환경 생성
+py -3.10 -m venv venv
+# 가상환경 활성화
+.\venv\Scripts\Activate
+```
+
+**3. 필수 라이브러리 설치**
+```bash
+# PyTorch (CUDA 11.8 버전)를 먼저 설치합니다.
+pip install torch torchvision torchaudio --index-url [https://download.pytorch.org/whl/cu118](https://download.pytorch.org/whl/cu118)
+# 나머지 라이브러리를 설치합니다.
+pip install -r requirements.txt
+```
+
+**4. AI 모델 훈련 (최초 1회 필수)**
+> **주의:** 이 과정은 AI Hub에서 '감성대화 말뭉치' 원본 데이터셋을 다운로드하여 `data` 폴더에 위치시킨 후 진행해야 합니다. 훈련에는 RTX 4060 GPU 기준 약 30-40분이 소요됩니다.
+
+```bash
+python train_model.py 
+```
+
+**5. 웹 애플리케이션 실행**
+```bash
+python app.py
+```
+* 서버가 실행되면, 웹 브라우저를 열고 주소창에 `http://127.0.0.1:5000` 을 입력하세요.
+
+<br>
+
+## 📊 모델 성능 (Model Performance)
+
+'감성대화 말뭉치' 검증 데이터셋(Validation Set)으로 평가한 최종 모델의 성능은 다음과 같습니다.
+
+| 평가지표 (Metric) | 점수 (Score) |
+| :--- | :---: |
+| **Accuracy** (정확도) | **85.3%** |
+| **F1-Score** (Weighted)| **0.852** |
+
+

notebooks/explore_data.py

@@ -0,0 +1,126 @@
+# 데이터셋의 사용 조사 보고 그래프
+
+import pandas as pd
+import json
+import re
+
+# 파일 경로 설정
+file_path = './data/'
+
+# 훈련 라벨 JSON 파일 불러오기
+with open(file_path + 'training-label.json', 'r', encoding='utf-8') as file:
+    training_data_raw = json.load(file)
+
+# 필요한 데이터만 추출하여 리스트에 저장
+extracted_data = []
+
+# 데이터는 리스트이므로 바로 순회합니다.
+for dialogue in training_data_raw:
+    try:
+        # 1. 감정 라벨 추출 (emotion 키는 profile 안에 있습니다)
+        emotion_type = dialogue['profile']['emotion']['type']
+        
+        # 2. 대화 텍스트 추출 (talk 키 안에 content가 있습니다)
+        dialogue_content = dialogue['talk']['content']
+        
+        # 3. 딕셔너리의 value들(텍스트)만 추출합니다.
+        texts = list(dialogue_content.values())
+        
+        # 4. 모든 텍스트를 하나의 문자열로 합칩니다.
+        # 빈 문자열을 제거하고 합치는 것이 좋습니다.
+        full_text = " ".join([text for text in texts if text.strip()])
+        
+        # 5. 합쳐진 텍스트와 감정 라벨이 모두 유효할 경우에만 추가합니다.
+        if full_text and emotion_type:
+            extracted_data.append({'text': full_text, 'emotion': emotion_type})
+            
+    except KeyError:
+        # 'profile', 'emotion', 'talk', 'content' 등의 키가 없는 항목은 건너뜁니다.
+        continue
+
+# 새로운 데이터프레임 생성
+df_train = pd.DataFrame(extracted_data)
+
+# 6. 합쳐진 데이터 확인
+print("--- 추출된 훈련 데이터프레임의 첫 5줄 ---")
+print(df_train.head())
+
+print("\n--- 데이터프레임 크기 ---")
+print(f"훈련 데이터: {df_train.shape}")
+
+# 기존 훈련 데이터 로드 코드 아래에 이어서 작성해 주세요.
+# ------------------------------------------------------------------
+
+# 1. 검증 라벨 JSON 파일 불러오기
+with open(file_path + 'validation-label.json', 'r', encoding='utf-8') as file:
+    validation_data_raw = json.load(file)
+
+# 2. 검증 데이터 추출
+extracted_val_data = []
+
+for dialogue in validation_data_raw:
+    try:
+        emotion_type = dialogue['profile']['emotion']['type']
+        dialogue_content = dialogue['talk']['content']
+        texts = list(dialogue_content.values())
+        full_text = " ".join([text for text in texts if text.strip()])
+
+        if full_text and emotion_type:
+            extracted_val_data.append({'text': full_text, 'emotion': emotion_type})
+            
+    except KeyError:
+        continue
+
+# 3. 새로운 데이터프레임 생성
+df_val = pd.DataFrame(extracted_val_data)
+
+# 4. 검증 데이터 확인
+print("\n--- 추출된 검증 데이터프레임의 첫 5줄 ---")
+print(df_val.head())
+
+print("\n--- 검증 데이터프레임 크기 ---")
+print(f"검증 데이터: {df_val.shape}")
+
+# main.py의 기존 코드 맨 아래에 이어서 작성합니다.
+# -----------------------------------------------------------
+# --- [Phase 1] 데이터 탐색 및 전처리 ---
+# -----------------------------------------------------------
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# 1. 데이터 탐색 및 시각화
+print("\n--- [Phase 1-1] 데이터 탐색 및 시각화 시작 ---")
+
+# 한글 폰트 설정 (Windows: Malgun Gothic, Mac: AppleGothic)
+plt.rcParams['font.family'] = 'Malgun Gothic'
+plt.rcParams['axes.unicode_minus'] = False # 마이너스 기호 깨짐 방지
+
+# 훈련 데이터의 감정 분포 확인
+print("\n--- 훈련 데이터 감정 분포 ---")
+print(df_train['emotion'].value_counts())
+
+# 감정 분포 시각화
+plt.figure(figsize=(10, 6))
+sns.countplot(data=df_train, y='emotion', order=df_train['emotion'].value_counts().index)
+plt.title('훈련 데이터 감정 분포 시각화', fontsize=15)
+plt.xlabel('개수', fontsize=12)
+plt.ylabel('감정', fontsize=12)
+plt.grid(axis='x', linestyle='--', alpha=0.7)
+plt.show() # 그래프 창 보여주기
+
+print("\n시각화 완료. 그래프 창을 닫으면 다음 단계가 진행됩니다.")
+
+# 2. 텍스트 정제
+print("\n--- [Phase 1-2] 텍스트 정제 시작 ---")
+# 이미 re 모듈은 위에서 import 했습니다.
+
+def clean_text(text):
+    # 정규표현식을 사용하여 한글, 영어, 숫자, 공백을 제외한 모든 문자 제거
+    return re.sub(r'[^가-힣a-zA-Z0-9 ]', '', text)
+
+# 훈련/검증 데이터에 정제 함수 적용
+df_train['cleaned_text'] = df_train['text'].apply(clean_text)
+df_val['cleaned_text'] = df_val['text'].apply(clean_text)
+
+print("텍스트 정제 완료.")
+print(df_train[['text', 'cleaned_text']].head())

scripts/save_complete_model.py

@@ -0,0 +1,20 @@
+# save_complete_model.py
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+
+# 기존 훈련 결과물이 저장된 경로
+checkpoint_path = "./results/checkpoint-9681"
+
+# '완전한 모델'을 저장할 새 폴더 이름
+output_dir = "./korean-emotion-classifier-final"
+
+print(f"'{checkpoint_path}'에서 모델과 토크나이저를 불러옵니다...")
+model = AutoModelForSequenceClassification.from_pretrained(checkpoint_path)
+tokenizer = AutoTokenizer.from_pretrained(checkpoint_path)
+print("불러오기 완료.")
+
+print(f"'{output_dir}' 폴더에 완전한 모델과 토크나이저를 저장합니다...")
+model.save_pretrained(output_dir)
+tokenizer.save_pretrained(output_dir)
+
+print("저장 완료! 'korean-emotion-classifier-final' 폴더를 확인하세요.")
+print("이 폴더 안의 파일들을 'my-local-model' 폴더로 옮겨주시면 됩니다.")

scripts/train_model.py

@@ -0,0 +1,149 @@
+# train_model.py
+# AI 모델을 훈련하는 스크립트, 다시 사용가능한 삭제 x
+
+import pandas as pd
+import json
+import re
+import sys
+import transformers
+import torch
+
+from transformers import AutoTokenizer
+
+# --- 1. 데이터 로딩 및 전처리 ---
+
+print("--- [Phase 1] 데이터 로딩 및 전처리 시작 ---")
+# 파일 경로 설정
+file_path = './data/'
+
+# 훈련/검증 데이터 로딩 (이전과 동일)
+with open(file_path + 'training-label.json', 'r', encoding='utf-8') as file:
+    training_data_raw = json.load(file)
+with open(file_path + 'validation-label.json', 'r', encoding='utf-8') as file:
+    validation_data_raw = json.load(file)
+
+# DataFrame 생성 함수 (코드를 깔끔하게 하기 위해 함수로 묶음)
+def create_dataframe(data_raw):
+    extracted_data = []
+    for dialogue in data_raw:
+        try:
+            emotion_type = dialogue['profile']['emotion']['type']
+            dialogue_content = dialogue['talk']['content']
+            full_text = " ".join(list(dialogue_content.values()))
+            if full_text and emotion_type:
+                extracted_data.append({'text': full_text, 'emotion': emotion_type})
+        except KeyError:
+            continue
+    return pd.DataFrame(extracted_data)
+
+df_train = create_dataframe(training_data_raw)
+df_val = create_dataframe(validation_data_raw)
+
+# 텍스트 정제
+def clean_text(text):
+    return re.sub(r'[^가-힣a-zA-Z0-9 ]', '', text)
+
+df_train['cleaned_text'] = df_train['text'].apply(clean_text)
+df_val['cleaned_text'] = df_val['text'].apply(clean_text)
+print("✅ 데이터 로딩 및 전처리 완료!")
+
+
+# --- 2. AI 모델링 준비 ---
+print("\n--- [Phase 2] AI 모델링 준비 시작 ---")
+# 모델 및 토크나이저 불러오기
+MODEL_NAME = "klue/roberta-base"
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+
+# 텍스트 토큰화
+train_tokenized = tokenizer(list(df_train['cleaned_text']), return_tensors="pt", max_length=128, padding=True, truncation=True)
+val_tokenized = tokenizer(list(df_val['cleaned_text']), return_tensors="pt", max_length=128, padding=True, truncation=True)
+
+# 라벨 인코딩
+unique_labels = sorted(df_train['emotion'].unique())
+label_to_id = {label: id for id, label in enumerate(unique_labels)}
+id_to_label = {id: label for label, id in label_to_id.items()}
+df_train['label'] = df_train['emotion'].map(label_to_id)
+df_val['label'] = df_val['emotion'].map(label_to_id)
+print("✅ 토큰화 및 라벨 인코딩 완료!")
+print("이제 모델 훈련을 위한 모든 준비가 끝났습니다.")
+
+
+# [Phase 3]의 기존 코드를 아래 내용으로 교체해주세요.
+# -----------------------------------------------------------
+# --- [Phase 3] 모델 학습 및 평가 (최소 기능 버전) ---
+# -----------------------------------------------------------
+import torch
+from transformers import AutoModelForSequenceClassification, TrainingArguments, Trainer
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support
+
+print("\n--- [Phase 3] 모델 학습 및 평가 시작 ---")
+
+# 1. PyTorch Dataset 클래스 정의 (이전과 동일)
+class EmotionDataset(torch.utils.data.Dataset):
+    def __init__(self, encodings, labels):
+        self.encodings = encodings
+        self.labels = labels
+    def __getitem__(self, idx):
+        item = {key: val[idx].clone().detach() for key, val in self.encodings.items()}
+        item['labels'] = torch.tensor(self.labels[idx])
+        return item
+    def __len__(self):
+        return len(self.labels)
+
+train_dataset = EmotionDataset(train_tokenized, df_train['label'].tolist())
+val_dataset = EmotionDataset(val_tokenized, df_val['label'].tolist())
+print("✅ PyTorch 데이터셋 생성이 완료되었습니다.")
+
+# 2. AI 모델 불러오기 (이전과 동일)
+model = AutoModelForSequenceClassification.from_pretrained(
+    MODEL_NAME, 
+    num_labels=len(unique_labels),
+    id2label=id_to_label,
+    label2id=label_to_id
+)
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+model.to(device)
+print(f"✅ 모델 로딩 완료! 모델은 {device}에서 실행됩니다.")
+
+
+# 3. 모델 성능 평가를 위한 함수 정의 (수정 완료)
+def compute_metrics(pred):
+    labels = pred.label_ids
+    # 바로 이 부분이 수정되었습니다.
+    preds = pred.predictions.argmax(-1)
+    
+    precision, recall, f1, _ = precision_recall_fscore_support(labels, preds, average='weighted', zero_division=0)
+    acc = accuracy_score(labels, preds)
+    return {'accuracy': acc, 'f1': f1, 'precision': precision, 'recall': recall}
+
+# 4. 훈련을 위한 상세 설정(Arguments) 정의 (모든 부가 옵션 제거)
+training_args = TrainingArguments(
+    output_dir='./results',          # 모델이 저장될 위치 (필수)
+    num_train_epochs=3,              # 훈련 횟수
+    per_device_train_batch_size=16,  # 훈련 배치 사이즈
+    # 나머지 모든 평가/저장 관련 옵션은 모두 제거합니다.
+)
+
+# ---!!! 핵심 수��� 사항 2 !!!---
+# 5. Trainer 정의 (평가 관련 기능 비활성화)
+trainer = Trainer(
+    model=model,
+    args=training_args,
+    train_dataset=train_dataset,
+    # 훈련 중 평가를 하지 않으므로 아래 옵션들은 제외합니다.
+    # eval_dataset=val_dataset,
+    # compute_metrics=compute_metrics
+)
+
+# 6. 모델 훈련 시작!
+print("\n🔥 AI 모델 훈련을 시작합니다...")
+trainer.train()
+print("\n🎉 모델 훈련 완료!")
+
+# 7. 최종 모델 평가는 훈련이 끝난 후 '별도로' 실행
+print("\n--- 최종 모델 성능 평가 ---")
+# 비활성화했던 평가 데이터셋을 evaluate 함수에 직접 전달해줍니다.
+final_evaluation = trainer.evaluate(eval_dataset=val_dataset) 
+print(final_evaluation)
+
+print("\n모든 과정이 성공적으로 끝났습니다! results 폴더에서 훈련된 모델을 확인하세요.")

scripts/upload_model.py

@@ -0,0 +1,30 @@
+# upload_model.py
+
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+
+# ---!!! 1. 이 부분을 최종적으로 결정한 정보로 수정해주세요 !!!---
+YOUR_HF_ID = "taehoon222"  # 사용자님의 Hugging Face ID
+YOUR_MODEL_NAME = "korean-emotion-classifier" # 추천 모델 이름 (원하는 이름으로 변경 가능)
+# ----------------------------------------------------
+
+# 2. 내 컴퓨터에 저장된, 훈련이 완료된 모델의 경로
+LOCAL_MODEL_PATH = 'E:/sentiment_analysis_project/results/checkpoint-9681'
+
+print(f"'{LOCAL_MODEL_PATH}'에서 모델을 불러옵니다...")
+try:
+    tokenizer = AutoTokenizer.from_pretrained(LOCAL_MODEL_PATH)
+    model = AutoModelForSequenceClassification.from_pretrained(LOCAL_MODEL_PATH)
+    print("✅ 로컬 모델 로딩 성공!")
+except Exception as e:
+    print(f"❌ 로컬 모델을 불러오는 데 실패했습니다: {e}")
+    exit()
+
+# 3. Hugging Face Hub에 업로드합니다.
+NEW_REPO_ID = f"{YOUR_HF_ID}/{YOUR_MODEL_NAME}"
+print(f"'{NEW_REPO_ID}' 이름으로 Hub에 업로드를 시작합니다...")
+try:
+    tokenizer.push_to_hub(NEW_REPO_ID)
+    model.push_to_hub(NEW_REPO_ID)
+    print("\n🎉🎉🎉 모델 업로드에 성공했습니다! 🎉🎉🎉")
+except Exception as e:
+    print(f"\n❌ 업로드 중 오류가 발생했습니다: {e}")

src/app.py

@@ -0,0 +1,68 @@
+# app.py
+
+from flask import Flask, render_template, request, jsonify
+# emotion_engine.py에서 두 함수를 모두 올바르게 import 합니다.
+from emotion_engine import load_emotion_classifier, predict_emotion
+# recommender.py에서 대문자 Recommender '클래스'를 올바르게 import 합니다.
+from recommender import Recommender
+import random
+
+app = Flask(__name__)
+
+print("AI 챗봇 서버를 준비 중입니다...")
+# 서버가 시작될 때 AI 엔진과 추천기를 각각 한 번씩만 로드합니다.
+emotion_classifier = load_emotion_classifier()
+recommender = Recommender()
+# 웹페이지에 감정별 이모지를 보내주기 위한 딕셔너리입니다.
+emotion_emoji_map = {
+    '기쁨': '😄', '행복': '😊', '사랑': '❤️',
+    '불안': '😟', '슬픔': '😢', '상처': '💔',
+    '분노': '😠', '혐오': '🤢', '짜증': '😤',
+    '놀람': '😮',
+    '중립': '😐',
+}
+print("✅ AI 챗봇 서버가 성공적으로 준비되었습니다.")
+
+@app.route("/")
+def home():
+    """웹 브라우저가 처음 접속했을 때 보여줄 메인 페이지를 설정합니다."""
+    # templates 폴더 안에 있는 emotion_homepage.html 파일을 화면에 보여줍니다.
+    return render_template("emotion_homepage.html")
+
+@app.route("/api/recommend", methods=["POST"])
+def api_recommend():
+    """웹페이지의 '추천 받기' 버튼 클릭 요청을 처리하는 부분입니다."""
+    # 1. 웹페이지로부터 사용자가 입력한 일기 내용을 받습니다.
+    user_diary = request.json.get("diary")
+    if not user_diary:
+        return jsonify({"error": "일기 내용이 없습니다."}), 400
+
+    # 2. emotion_engine을 사용해 감정을 예측합니다.
+    predicted_emotion = predict_emotion(emotion_classifier, user_diary)
+    
+    # 3. recommender를 사용해 '수용'과 '전환' 추천을 모두 받습니다.
+    accept_recs = recommender.recommend(predicted_emotion, "수용")
+    change_recs = recommender.recommend(predicted_emotion, "전환")
+    
+    # 4. 각 추천 목록에서 랜덤으로 하나씩 선택합니다. (결과가 없을 경우를 대비)
+    accept_choice = random.choice(accept_recs) if accept_recs else "추천 없음"
+    change_choice = random.choice(change_recs) if change_recs else "추천 없음"
+
+    # 5. 웹페이지에 보여줄 최종 텍스트를 조합합니다.
+    recommendation_text = (
+        f"<b>[ 이 감정을 더 깊이 느끼고 싶다면... (수용) ]</b><br>"
+        f"• {accept_choice}<br><br>"
+        f"<b>[ 이 감정에서 벗어나고 싶다면... (전환) ]</b><br>"
+        f"• {change_choice}"
+    )
+
+    # 6. 최종 결과를 JSON 형태로 웹페이지에 돌려줍니다.
+    response_data = {
+        "emotion": predicted_emotion,
+        "emoji": emotion_emoji_map.get(predicted_emotion, '🤔'),
+        "recommendation": recommendation_text
+    }
+    return jsonify(response_data)
+
+if __name__ == "__main__":
+    app.run(debug=True)

src/emotion_engine.py

@@ -0,0 +1,46 @@
+# emotion_engine.py
+
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
+import os
+
+def load_emotion_classifier():
+    # 현재 스크립트 파일의 디렉터리 경로를 가져옵니다.
+    base_path = os.path.dirname(os.path.abspath(__file__))
+    
+    # 모델 폴더의 절대 경로를 만듭니다.
+    MODEL_PATH = os.path.join(base_path, "korean-emotion-classifier-final")
+    
+    # 경로가 로컬 디렉터리인지 확인
+    if not os.path.isdir(MODEL_PATH):
+        print(f"❌ 오류: 지정된 경로 '{MODEL_PATH}'에 모델 폴더가 존재하지 않습니다.")
+        return None
+        
+    print(f"--- 최종 모델 경로 확인: [{MODEL_PATH}] ---")
+    print(f"로컬 절대 경로 '{MODEL_PATH}'에서 모델을 직접 불러옵니다...")
+    
+    try:
+        # 1. from_pretrained()에 절대 경로를 직접 전달합니다.
+        # 2. `local_files_only=True`는 제거합니다. 라이브러리가 자동으로 인식합니다.
+        tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
+        model = AutoModelForSequenceClassification.from_pretrained(MODEL_PATH)
+        
+        print("✅ 로컬 모델 파일 직접 로딩 성공!")
+
+    except Exception as e:
+        print(f"❌ 모델 로딩 중 오류: {e}")
+        # 오류가 발생한 원인을 정확히 출력합니다.
+        print(f"상세 오류 메시지: {e}")
+        return None
+    
+    device = 0 if torch.cuda.is_available() else -1
+    emotion_classifier = pipeline("text-classification", model=model, tokenizer=tokenizer, device=device)
+    
+    return emotion_classifier
+
+# predict_emotion 함수는 그대로 둡니다.
+def predict_emotion(classifier, text):
+    if not text or not text.strip(): return "내용 없음"
+    if classifier is None: return "오류: 감정 분석 엔진 준비 안됨."
+    result = classifier(text)
+    return result[0]['label']

src/recommender.py

@@ -0,0 +1,44 @@
+# recommender.py
+
+class Recommender:
+    """
+    감정과 사용자 선택에 따라 콘텐츠를 추천하는 클래스입니다.
+    """
+    def __init__(self):
+        self.recommendation_db = {
+            '기쁨': {
+                '수용': ["영화: 월터의 상상은 현실이 된다", "음악: Pharrell Williams - Happy", "책: 창문 넘어 도망친 100세 노인"],
+                '전환': ["영화: 쇼생크 탈출", "음악: 이루마 - River Flows In You"]
+            },
+            '행복': {
+                '수용': ["영화: 비긴 어게인", "음악: 쿨 - All for You", "책: 꾸뻬씨의 행복여행"],
+                '전환': ["영화: 포레스트 검프", "음악: 토이 - 좋은 사람"]
+            },
+            '불안': {
+                '수용': ["영화: 인사이드 아웃", "음악: 위로가 되는 연주곡 플레이리스트", "책: 미움받을 용기"],
+                '전환': ["영화: 극한직업", "음악: Maroon 5 - Moves Like Jagger"]
+            },
+            '분노': {
+                '수용': ["영화: 존 윅", "음악: 람슈타인 - Du Hast"],
+                '전환': ["영화: 리틀 포레스트", "음악: 노라 존스 - Don't Know Why"]
+            },
+            '슬픔': {
+                '수용': ["영화: 이터널 선샤인", "음악: 박효신 - 눈의 꽃", "책: 1리터의 눈물"],
+                '전환': ["영화: 월-E", "음악: 거북이 - 비행기"]
+            },
+            '상처': {
+                '수용': ["영화: 캐스트 어웨이", "음악: 김광석 - 서른 즈음에", "책: 죽고 싶지만 떡볶이는 먹고 싶어"],
+                '전환': ["영화: 글러브 (승패를 떠난 야구의 순수한 열정과 감동을 느껴보세요)", "음악: 옥상달빛 - 수고했어, 오늘도"]
+            },
+            '놀람': {
+                '수용': ["영화: 식스 센스", "음악: 박진영 - 어머님이 누구니"],
+                '전환': ["음악: Bach - Air on G String", "책: 고요할수록 밝아지는 것들"]
+            },
+            '중립': {
+                '수용': ["영화: 패터슨", "음악: 잔잔한 Lo-fi 플레이리스트", "책: 보통의 존재"],
+                '전환': ["영화: 스파이더맨: 뉴 유니버스", "음악: Queen - Don't Stop Me Now"]
+            },
+        }
+
+    def recommend(self, emotion: str, choice: str) -> list:
+        return self.recommendation_db.get(emotion, {}).get(choice, ["😥 아쉽지만, 아직 준비된 추천이 없어요."])

templates/emotion_homepage.html

@@ -0,0 +1,229 @@
+<!-- 홈페이지 -->
+
+<!DOCTYPE html>
+<html lang="ko">
+<head>
+    <meta charset="UTF-8">
+    <title> 일기 기반 추천 웹페이지</title>
+    <style>
+        body {
+            font-family: "Spoqa Han Sans Neo", Arial, sans-serif;
+            padding: 50px;
+            background: linear-gradient(135deg, #ece9f7, #cacae0); /* 기본 배경 */
+            transition: background 0.5s ease;
+        }
+        .container {
+            background: white;
+            border-radius: 20px;
+            padding: 30px;
+            box-shadow: 0 8px 32px #0001;
+            max-width: 600px;
+            margin: 40px auto;
+        }
+        h1 { color: #65e5c9; margin-bottom: 18px; }
+        textarea {
+            width: 100%;
+            border-radius: 8px;
+            border: 1px solid #d0d0e0;
+            padding: 16px;
+            font-size: 18px;
+            margin-bottom: 12px;
+            background: #f7f7fb;
+            resize: vertical;
+        }
+        button {
+            background: #6598e5;
+            color: white;
+            padding: 12px 24px;
+            border-radius: 8px;
+            border: none;
+            font-size: 18px;
+            cursor: pointer;
+            transition: 0.2s;
+            margin-right: 8px;
+        }
+        button:hover { background: #5540a3; }
+        #result {
+            margin-top: 24px;
+            font-size: 17px;
+            color: #444a70;
+            background: #f2f2f7;
+            border-radius: 8px;
+            padding: 18px;
+            box-shadow: 0 2px 8px #cfcfe0;
+            min-height: 40px;
+        }
+        .history-title {
+            margin: 32px 0 12px 0;
+            color: #8855b0;
+            font-size: 20px;
+        }
+        #history {
+            background: #fff9;
+            border-radius: 10px;
+            padding: 14px 12px;
+            font-size: 15px;
+            min-height: 40px;
+            box-shadow: 0 2px 8px #edebf5;
+            margin-bottom: 15px;
+        }
+        .history-item {
+            margin-bottom: 8px;
+            border-bottom: 1px solid #eee;
+            padding-bottom: 6px;
+        }
+        .history-date {
+            color: #b2a4d4;
+            font-size: 13px;
+            margin-bottom: 3px;
+            display: block;
+        }
+        .clear-btn {
+            background: #e25b66;
+            color: white;
+            font-size: 14px;
+            padding: 7px 13px;
+            border-radius: 6px;
+            border: none;
+            cursor: pointer;
+            float: right;
+            transition: 0.2s;
+        }
+        .clear-btn:hover { background: #c73442; }
+        /* 테마 변경 버튼 스타일 */
+        .theme-buttons {
+            text-align: right;
+            margin-bottom: 15px;
+        }
+        .theme-buttons button {
+            font-size: 14px;
+            padding: 5px 10px;
+            margin-left: 5px;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+
+        <!-- 테마 변경 버튼 -->
+        <div class="theme-buttons">
+            <button onclick="changeTheme('light')">🌞 밝은 모드</button>
+            <button onclick="changeTheme('dark')">🌙 어두운 모드</button>
+            <button onclick="changeTheme('pastel')">🎨 파스텔 모드</button>
+        </div>
+
+        <h1>오늘의 일기 입력</h1>
+        <textarea id="diary" placeholder="오늘 있었던 일을 자유롭게 입력해 보세요."></textarea><br>
+        <button onclick="recommend()">추천 받기</button>
+        <div id="result"></div>
+
+        <div class="history-title">
+            나의 일기 히스토리
+            <button class="clear-btn" onclick="clearHistory()">모두 지우기</button>
+        </div>
+        <div id="history"></div>
+    </div>
+
+    <script>
+        // 테마 변경 함수 + 로컬스토리지 저장
+        function changeTheme(mode) {
+            if (mode === 'light') {
+                document.body.style.background = 'linear-gradient(135deg, #ffffff, #f0f0f0)';
+            } 
+            else if (mode === 'dark') {
+                document.body.style.background = 'linear-gradient(135deg, #2c2c3e, #1a1a28)';
+            } 
+            else if (mode === 'pastel') {
+                document.body.style.background = 'linear-gradient(135deg, #ffefd5, #ffe4e1)';
+            }
+            localStorage.setItem('selectedTheme', mode); // 선택한 테마 저장
+        }
+
+        // 페이지 로드시 저장된 테마 불러오기
+        window.onload = function() {
+            const savedTheme = localStorage.getItem('selectedTheme');
+            if (savedTheme) {
+                changeTheme(savedTheme);
+            }
+            renderHistory();
+        };
+
+        async function recommend() {
+            const diary = document.getElementById('diary').value.trim();
+            const resultDiv = document.getElementById('result');
+
+            if (!diary) {
+                resultDiv.innerHTML = "일기 내용�� 입력해 주세요.";
+                return;
+            }
+
+            resultDiv.innerHTML = "추천 콘텐츠를 생성 중입니다. 잠시만 기다려주세요...";
+
+            try {
+                const response = await fetch('/api/recommend', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ diary })
+                });
+                const data = await response.json();
+
+                if (data.error) {
+                    resultDiv.innerHTML = `오류: ${data.error}`;
+                } else {
+                    resultDiv.innerHTML = `
+                        <strong>감정분석:</strong> ${data.emotion} ${data.emoji}<br>
+                        <strong>추천:</strong> ${data.recommendation}
+                    `;
+                    saveDiary({
+                        text: diary,
+                        emotion: data.emotion,
+                        emoji: data.emoji,
+                        date: new Date().toISOString()
+                    });
+                    renderHistory();
+                }
+            } catch (error) {
+                console.error('Fetch error:', error);
+                resultDiv.innerHTML = '서버 통신 중 오류가 발생했습니다.';
+            }
+        }
+
+        function saveDiary(entry) {
+            let diaryHistory = JSON.parse(localStorage.getItem('diaryHistory') || '[]');
+            diaryHistory.unshift(entry);
+            if (diaryHistory.length > 20) diaryHistory = diaryHistory.slice(0, 20);
+            localStorage.setItem('diaryHistory', JSON.stringify(diaryHistory));
+        }
+
+        function renderHistory() {
+            const historyDiv = document.getElementById('history');
+            const diaryHistory = JSON.parse(localStorage.getItem('diaryHistory') || '[]');
+
+            if (!diaryHistory.length) {
+                historyDiv.innerHTML = "저장된 일기가 없습니다.";
+                return;
+            }
+
+            historyDiv.innerHTML = diaryHistory.map(item => `
+                <div class="history-item">
+                    <span class="history-date">
+                        ${new Date(item.date).toLocaleString('ko-KR', { 
+                            year: 'numeric', month: '2-digit', day: '2-digit', 
+                            hour: '2-digit', minute: '2-digit' 
+                        })}
+                    </span>
+                    <span>${item.emoji} <strong>[${item.emotion}]</strong> : ${item.text}</span>
+                </div>
+            `).join('');
+        }
+
+        function clearHistory() {
+            if (confirm('정말 모두 삭제하시겠어요?')) {
+                localStorage.removeItem('diaryHistory');
+                renderHistory();
+                document.getElementById('result').innerHTML = '';
+            }
+        }
+    </script>
+</body>
+</html>