Initial commit for Hugging Face

.dockerignore

@@ -0,0 +1,80 @@
+# flyctl launch added from .gitignore
+# Byte-compiled / optimized / DLL files
+**/__pycache__
+**/*.py[cod]
+**/*$py.class
+
+# C extensions
+**/*.so
+
+# Distribution / packaging
+**/.Python
+**/build
+**/develop-eggs
+**/dist
+**/downloads
+**/eggs
+**/.eggs
+**/lib
+**/lib64
+**/parts
+**/sdist
+**/var
+**/wheels
+**/*.egg-info
+**/.installed.cfg
+**/*.egg
+
+# PyInstaller
+**/*.manifest
+**/*.spec
+
+# Installer logs
+**/pip-log.txt
+**/pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+**/htmlcov
+**/.tox
+**/.coverage
+**/.coverage.*
+**/.cache
+**/nosetests.xml
+**/coverage.xml
+**/*.cover
+**/.hypothesis
+**/.pytest_cache
+
+# Translations
+**/*.mo
+**/*.pot
+
+# Jupyter Notebook
+**/.ipynb_checkpoints
+
+# pyenv
+**/.python-version
+
+# Environments
+**/.env
+**/.venv
+**/env
+**/venv
+**/ENV
+**/env.bak
+**/venv.bak
+
+# IDE
+**/.idea
+**/.vscode
+**/*.swp
+**/*.swo
+**/*~
+
+# OS
+**/.DS_Store
+**/Thumbs.db
+
+# Local settings
+**/.streamlit/secrets.toml
+fly.toml

.gitattributes

@@ -0,0 +1,8 @@
+models/d2v.model filter=lfs diff=lfs merge=lfs -text
+models/d2v.model.dv.vectors.npy filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+models/w2v.model filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text
+src/font.ttf filter=lfs diff=lfs merge=lfs -text

.github/workflows/fly-deploy.yml

@@ -0,0 +1,18 @@
+# See https://fly.io/docs/app-guides/continuous-deployment-with-github-actions/
+
+name: Fly Deploy
+on:
+  push:
+    branches:
+      - main
+jobs:
+  deploy:
+    name: Deploy app
+    runs-on: ubuntu-latest
+    concurrency: deploy-group    # optional: ensure only one action runs at a time
+    steps:
+      - uses: actions/checkout@v4
+      - uses: superfly/flyctl-actions/setup-flyctl@master
+      - run: flyctl deploy --remote-only
+        env:
+          FLY_API_TOKEN: ${{ secrets.FLY_API_TOKEN }}

.gitignore

@@ -0,0 +1,78 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Local settings
+.streamlit/secrets.toml

Dockerfile

@@ -0,0 +1,22 @@
+FROM python:3.9-slim
+
+# 보안 및 권한 설정을 위한 유저 생성 (Hugging Face 권장 사항)
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+# 의존성 설치
+COPY --chown=user requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# 코드 복사 (모델 파일 포함)
+COPY --chown=user . .
+
+# 포트 설정 (Hugging Face는 7860 포트를 사용합니다)
+EXPOSE 7860
+
+# 실행 명령어
+CMD ["uvicorn", "src.api:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,87 @@
+# 🍳 K-Recipe2Vec
+
+AI 기반 한식 식재료 대체 추천 서비스
+
+## 📖 Overview
+
+한국 요리에서 식재료를 대체할 수 있는 재료를 AI가 추천해주는 웹 서비스입니다.  
+Doc2Vec과 Word2Vec 모델을 활용하여 식재료 간의 의미적 유사도를 분석합니다.
+
+## 🔗 Demo
+
+🚀 **[Live Demo](https://korea-recipe-ai.streamlit.app/)** - Streamlit Cloud 배포
+
+## ✨ Features
+
+- **🥬 식재료 대체 추천**: 없는 재료에 대한 유사 재료 추천
+- **📊 3D 시각화**: PCA 기반 재료 벡터 공간 시각화
+- **💰 가격 정보**: 재료별 가격 정보 제공
+- **☁️ 워드클라우드**: 추천 재료 시각화
+
+## 🛠️ Tech Stack
+
+| Category | Technologies |
+|----------|-------------|
+| **Frontend** | Streamlit |
+| **ML Models** | Gensim (Doc2Vec, Word2Vec) |
+| **Data Processing** | Pandas, NumPy |
+| **Visualization** | Plotly, Matplotlib, WordCloud |
+| **Database** | Supabase |
+| **Deployment** | Streamlit Cloud |
+
+## 📁 Project Structure
+
+```
+k-recipe2vec/
+├── app.py              # Main Streamlit application
+├── logic.py            # Core recommendation logic (if exists)
+├── requirements.txt    # Python dependencies
+├── d2v.model          # Doc2Vec trained model
+├── w2v.model          # Word2Vec trained model
+├── price_rank.csv     # Price data
+└── stats.pkl          # Preprocessed statistics
+```
+
+## 🚀 Getting Started
+
+### Prerequisites
+
+- Python 3.8+
+- pip
+
+### Installation
+
+```bash
+# Clone the repository
+git clone https://github.com/nneans/k-recipe2vec.git
+cd k-recipe2vec
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Run the app
+streamlit run src/app.py
+```
+
+## 📊 Model Information
+
+### Doc2Vec Model
+- 한국 레시피 데이터 기반 학습
+- 레시피 단위 문서 임베딩
+
+### Word2Vec Model
+- 식재료 간 의미적 유사도 학습
+- 대체 가능한 재료 추천에 활용
+
+## 🤝 Contributing
+
+버그 리포트, 기능 제안, PR 환영합니다!
+
+## 📝 License
+
+MIT License
+
+## 👤 Author
+
+**Mingyun Kang**
+- GitHub: [@nneans](https://github.com/nneans)

data/final_recipe_data.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f6379eeed75a6d8b2f44a8a3e713c0b3bb3f1af58d0ed92ee0b8a2523cf9e65
+size 31853277

data/stats.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e2564ef8229041aadab57e0d4c371bb6ba781ceb0815390909fbc45851571304
+size 14211436

docs/logic_explanation.md

@@ -0,0 +1,72 @@
+### AI 추천 로직 상세 해부
+
+이 시스템은 12만여 개의 한식 레시피 데이터를 학습한 AI가 재료의 의미와 문맥을 분석합니다. 단순히 이름이 비슷한 재료가 아닌, **'지금 이 요리에 가장 잘 어울리는'** 최적의 대안을 찾아내는 과정입니다.
+
+---
+
+#### 💡 AI는 재료를 어떻게 이해할까요? (3차원 벡터 공간 예시)
+AI는 모든 식재료를 거대한 3차원 공간(실제로는 수백 차원) 속의 **'좌표(벡터)'**로 인식합니다.
+* **유사도가 높다는 뜻:** 이 공간에서 두 재료의 좌표가 서로 **가까운 위치**에 모여 있거나, 원점에서 뻗어나가는 **화살표의 방향이 비슷하다**는 의미입니다.
+
+위 그림처럼 '돼지고기'와 '소고기'는 '육류'라는 비슷한 성질을 가져 공간상에서 가까운 위치에 모여 있습니다. 반면, '사과'는 성질이 다르기 때문에 멀리 떨어져 있습니다. AI는 이 **'거리와 방향의 멂과 가까움'**을 계산하여 추천에 활용합니다.
+
+---
+
+#### 1단계. 의미 파악 (Word2Vec): "친구를 보면 너를 알 수 있어"
+* **핵심 원리:** AI는 재료의 맛이나 식감을 직접 알지 못합니다. 대신 **'함께 자주 쓰이는 주변 재료(문맥)'**가 비슷할수록 유사한 역할을 하는 재료로 학습합니다.
+* **예시 (타겟 재료: 돼지고기)**
+    * **돼지고기**의 친구들: [간장, 마늘, 양파, 고추장, 김치, 볶기]
+    * 🥩 **소고기 (유사도 0.85):** [간장, 마늘, 양파, 참기름, 불고기] → 겹치는 친구가 매우 많음 (비슷한 재료!)
+    * 🐟 **고등어 (유사도 0.45):** [간장, 마늘, **무, 생강, 비린내**] → 일부 겹치지만, 다른 친구들도 많음 (조금 다른 재료)
+    * 🍎 **사과 (유사도 0.10):** [설탕, **마요네즈, 샐러드, 아침**] → 겹치는 친구가 거의 없음 (완전히 다른 재료)
+
+#### 2단계. 문맥 이해 (Doc2Vec): "같은 조리법 상황에서의 궁합 파악"
+* **핵심 (코드 구현 내용):** 단순히 '이 재료가 요리에 어울리나?'를 보는 것이 아니라, **'현재의 조리방법(예: 끓이기, 볶기)'과 동일한 상황에서** 잘 어울리는지를 판단합니다.
+* **작동 원리 (Ver.1 DB 모드 기준):**
+    1.  현재 타겟 요리의 **'조리방법'(예: 끓이기)**을 확인합니다.
+    2.  후보 재료가 사용된 수많은 레시피 중, **같은 조리방법('끓이기')이 사용된 레시피들만 골라냅니다.**
+    3.  골라낸 레시피들의 좌표가 현재 타겟 요리의 좌표와 얼마나 가까운지 비교합니다.
+* **왜 이렇게 하나요?** 같은 재료라도 '볶을 때'와 '끓일 때'의 역할이 다르기 때문입니다. 조리법 조건을 걸어 더 정확한 문맥 파악을 합니다.
+
+#### 3단계. 통계적 적합성 (Ver.1 DB 모드 전용): "데이터 검증 (Lift)"
+* **역할:** 실제 데이터에서 해당 재료가 특정 **조리법**이나 **요리 카테고리**에 '유독' 많이 쓰이는지 검증합니다. (여기서 카테고리 정보도 함께 활용됩니다.)
+* **핵심 개념 (Lift, 향상도):** 평균적인 사용 확률 대비, 특정 조건에서 사용 확률이 얼마나 높아지는지를 봅니다. 기준값은 **1**입니다.
+* **판단 기준:**
+    * **Lift > 1 (추천):** 평균보다 이 조건에서 더 자주 쓰임 (궁합이 좋음)
+    * **Lift ≈ 1 (보통):** 평균적인 수준으로 쓰임
+    * **Lift < 1 (비추천):** 평균보다 이 조건에서 덜 쓰임 (궁합이 안 좋음)
+* **예시 (조리법: 끓이기):** 두부(Lift **> 1**, 끓일 때 필수), 상추(Lift **< 1**, 끓일 때 안 씀)
+
+---
+
+#### 🚀 추천 알고리즘 심화: 어떻게 최적의 재료를 찾아낼까?
+
+**1. 단일 재료 대체 (Best N 찾기)**
+* 위 1~3단계 점수에 가중치를 적용한 **최종 종합 점수**를 계산하고, 점수가 가장 높은 순서대로 상위 N개의 재료를 추천합니다.
+
+**2. 다중 재료 대체 (최적 조합 찾기 - 빔 서치)**
+* 여러 재료를 동시에 바꿀 때는 경우의 수가 폭발적으로 늘어납니다. 이때 효율적인 탐색을 위해 **'빔 서치(Beam Search)'**를 사용합니다.
+* **작동 원리 (매 단계마다):**
+    1.  현재까지 구성된 조합에 새로운 재료 후보를 하나씩 추가해봅니다.
+    2.  새로운 조합의 점수를 계산합니다. (점수 = 현재까지의 점수 + 새 재료의 AI 점수)
+    3.  모든 후보 조합 중 **점수가 가장 높은 상위 K개(Beam Width)의 조합만 남기고** 나머지는 버립니다.
+    4.  이 과정을 목표한 재료 수만큼 반복하여 최종적으로 가장 좋은 조합을 찾아냅니다.
+> **💡 비유:** 어두운 숲속에서 보물을 찾을 때, 여러 갈래 길 중 가장 밝은 빛이 비추는 길 3곳(K=3)만 골라서 계속 따라가는 것과 같습니다.
+
+---
+
+#### 🏆 최종 종합 점수 계산 예시 (가중치 적용)
+**(시나리오: 김치찌개(끓이기, 국/탕)에서 '돼지고기' 대신 '참치캔' 추천 시)**
+
+* **1. 의미 점수:** 0.70 × 가중치 5.0 = **3.50**
+* **2. 문맥 점수:** 0.95 × 가중치 1.0 = **0.95** (같은 '끓이기' 요리들과 비교)
+* **3. 조리 통계:** 0.90 × 가중치 1.0 = **0.90** ('끓이기' 데이터 검증)
+* **4. 분류 통계:** 0.85 × 가중치 1.0 = **0.85** ('국/탕' 데이터 검증)
+
+👉 **총점:** 3.50 + 0.95 + 0.90 + 0.85 = **6.20** / (총 가중치 8.0) = **최종 적합도 77.5%**
+
+---
+
+#### 💰 예상 원가 변동 (별도 계산)
+AI 점수와 별개로 제공되는 참고 정보입니다. 실시간 정확한 시세가 아닌, **사전에 정의된 재료별 상대적 가격 등급(1~5등급)**을 기준으로 계산됩니다.
+* **예:** 돼지고기(4등급) ➡️ 두부(2등급) 대체 시 `4 - 2 = +2` (🟢 총 +2단계 절감 예상)

fly.toml

@@ -0,0 +1,32 @@
+# fly.toml app configuration file generated for k-recipe2vec
+#
+# See https://fly.io/docs/reference/configuration/ for information about how to use this file.
+#
+
+app = 'k-recipe2vec'
+primary_region = 'sjc'
+
+[build]
+
+[http_service]
+  internal_port = 8080
+  force_https = true
+  auto_stop_machines = 'stop'
+  auto_start_machines = true
+  min_machines_running = 1
+  processes = ['app']
+
+[[vm]]
+  memory = '512mb'
+  cpus = 1
+  cpu_kind = 'shared'
+
+swap_size_mb = 512
+
+[[services.http_checks]]
+  interval = "10s"
+  timeout = "5s"
+  grace_period = "600s"  # 중요: 앱 시작 대기 시간을 10분으로 설정
+  restart_limit = 0
+  method = "get"
+  path = "/"

models/d2v.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b5e9a9c8c6bc7acaa809206c065679f4535bd521da269e528cca50914276875b
+size 10299708

models/d2v.model.dv.vectors.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d3b053c724d19a192980f81be997c4a5750588cff4ae50b5e86cdf985bafdf47
+size 52294128

models/w2v.model

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:29715dd37205c6f72615f4dbd5cdf59ddd2a757aec82959ba1aa1f6c630496c2
+size 4529859

requirements.txt

@@ -0,0 +1,12 @@
+streamlit
+pandas
+numpy
+gensim
+scikit-learn
+matplotlib
+supabase
+wordcloud
+plotly
+
+fastapi
+uvicorn

src/api.py

@@ -0,0 +1,156 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List, Optional
+import sys
+import os
+import pandas as pd
+import numpy as np
+import threading
+
+# 같은 폴더의 logic.py 임포트를 위해 경로 추가
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+import logic
+
+app = FastAPI(title="K-Recipe2Vec API")
+
+# CORS 설정
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# --- Request Models ---
+class IngredientRequest(BaseModel):
+    recipe_id: int
+    target: List[str]
+    stopwords: List[str] = []
+    w_w2v: float = 0.5
+    w_d2v: float = 0.5
+    w_method: float = 0.0
+    w_cat: float = 0.0
+
+class CustomContextRequest(BaseModel):
+    context_ings: List[str]
+    target: List[str]
+    stopwords: List[str] = []
+    w_w2v: float = 0.5
+    w_d2v: float = 0.5
+    excluded: List[str] = []
+
+# --- Startup ---
+@app.on_event("startup")
+def startup_event():
+    # 백그라운드 스레드에서 모델 로딩 시작 (앱 시작을 막지 않음)
+    threading.Thread(target=logic.load_resources).start()
+
+# --- Endpoints ---
+
+@app.get("/")
+def health_check():
+    # 모델 로딩 상태 확인
+    status = "loading" if logic.df is None else "ok"
+    return {"status": status, "service": "K-Recipe2Vec API"}
+
+@app.get("/recipes/search")
+def search_recipes(q: str):
+    """요리명으로 레시피 검색"""
+    logic.ensure_initialized() # 로딩 대기
+    
+    if not q: return []
+    try:
+        mask = logic.df['요리명'].str.contains(q, case=False, na=False)
+        results = logic.df.loc[mask, ['레시피일련번호', '요리명', '재료토큰']].head(20)
+        
+        output = []
+        for _, row in results.iterrows():
+            output.append({
+                "id": int(row['레시피일련번호']),
+                "name": row['요리명'],
+                "ingredients": row['재료토큰']
+            })
+        return output
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/recipes/{recipe_id}")
+def get_recipe_detail(recipe_id: int):
+    """레시피 상세 정보 조회"""
+    logic.ensure_initialized() # 로딩 대기
+    
+    try:
+        row = logic.df[logic.df['레시피일련번호'] == recipe_id]
+        if row.empty:
+            raise HTTPException(status_code=404, detail="Recipe not found")
+        
+        row = row.iloc[0]
+        return {
+            "id": int(row['레시피일련번호']),
+            "name": row['요리명'],
+            "method": row['요리방법별명'],
+            "category": row['요리종류별명_세분화'],
+            "ingredients": row['재료토큰']
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/recommend/db/single")
+def recommend_db_single(req: IngredientRequest):
+    """DB 레시피 기반 단일 재료 대체"""
+    logic.ensure_initialized() # 로딩 대기
+    
+    if not req.target:
+        raise HTTPException(status_code=400, detail="Target ingredient required")
+    try:
+        df = logic.substitute_single(
+            req.recipe_id, req.target[0], req.stopwords,
+            req.w_w2v, req.w_d2v, req.w_method, req.w_cat
+        )
+        if df.empty: return []
+        df = df.replace([np.inf, -np.inf], 0).fillna(0)
+        return df.to_dict(orient="records")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/recommend/db/multi")
+def recommend_db_multi(req: IngredientRequest):
+    """DB 레시피 기반 다중 재료 대체"""
+    logic.ensure_initialized() # 로딩 대기
+    
+    try:
+        results = logic.substitute_multi(
+            req.recipe_id, req.target, req.stopwords,
+            req.w_w2v, req.w_d2v, req.w_method, req.w_cat
+        )
+        formatted = []
+        for subs, score, saving in results:
+            formatted.append({
+                "substitutes": subs,
+                "score": float(score),
+                "saving_score": int(saving)
+            })
+        return formatted
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/recommend/custom/single")
+def recommend_custom_single(req: CustomContextRequest):
+    """사용자 정의 재료 기반 단일 대체"""
+    logic.ensure_initialized() # 로딩 대기
+
+    if not req.target:
+        raise HTTPException(status_code=400, detail="Target ingredient required")
+    try:
+        df = logic.substitute_single_custom(
+            req.target[0], req.context_ings, req.stopwords,
+            req.w_w2v, req.w_d2v, excluded_ings=req.excluded
+        )
+        if df.empty: return []
+        df = df.replace([np.inf, -np.inf], 0).fillna(0)
+        return df.to_dict(orient="records")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

src/app.py

@@ -0,0 +1,494 @@
+# app.py
+import streamlit as st
+import pandas as pd
+import logic
+import os
+from datetime import datetime, timedelta, timezone
+from wordcloud import WordCloud
+import matplotlib.pyplot as plt
+# [NEW] 3D 시각화를 위한 라이브러리
+import plotly.express as px
+from sklearn.decomposition import PCA
+import numpy as np
+
+# -------------------------------------------------------------------------
+# 1. 페이지 기본 설정 & 세션 상태 초기화
+# -------------------------------------------------------------------------
+st.set_page_config(page_title="AI 한식 재료 추천", layout="wide")
+st.title("🍳 AI 식재료 대체 추천 대시보드")
+
+# [NEW] 포트폴리오 스타일 적용 (Nanum Pen Script & Theme)
+st.markdown("""
+<style>
+    @import url('https://fonts.googleapis.com/css2?family=Nanum+Pen+Script&display=swap');
+    
+    html, body, [class*="css"] {
+        font-family: 'Nanum Pen Script', cursive !important;
+        font-size: 1.25rem;
+    }
+    
+    /* 제목 폰트 크기 키우기 */
+    h1 { font-size: 3.5rem !important; color: #1e293b !important; }
+    h2 { font-size: 2.8rem !important; color: #334155 !important; }
+    h3 { font-size: 2.2rem !important; color: #475569 !important; }
+    
+    /* 배경 그라데이션 (포트폴리오와 유사하게) */
+    .stApp {
+        background: linear-gradient(135deg, #f8fafc 0%, #e2e8f0 100%) !important;
+    }
+    
+    /* 설명 박스 스타일 */
+    div[data-testid="stMarkdownContainer"] > div {
+       font-family: 'Nanum Pen Script', cursive !important;
+    }
+
+    /* 버튼 스타일 */
+    .stButton > button {
+        background: #3b82f6 !important;
+        color: white !important;
+        border-radius: 12px !important;
+        border: none !important;
+        font-family: 'Nanum Pen Script', cursive !important;
+        font-size: 1.4rem !important;
+        padding: 0.5rem 1rem !important;
+        box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);
+        transition: all 0.2s;
+    }
+    .stButton > button:hover {
+        transform: scale(1.05);
+        opacity: 0.9;
+        box-shadow: 0 10px 15px -3px rgba(0, 0, 0, 0.1);
+    }
+    
+    /* 입력 필드 스타일 */
+    .stTextInput > div > div > input, .stTextArea > div > div > textarea {
+        background-color: rgba(255, 255, 255, 0.9) !important;
+        border-radius: 10px !important;
+        border: 1px solid #cbd5e1 !important;
+        font-family: 'Nanum Pen Script', cursive !important;
+        font-size: 1.2rem !important;
+        color: #1e293b !important;
+    }
+    
+    /* Expander 스타일 */
+    .streamlit-expanderHeader {
+        font-family: 'Nanum Pen Script', cursive !important;
+        font-size: 1.3rem !important;
+        background-color: rgba(255, 255, 255, 0.5) !important;
+        border-radius: 8px !important;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+if 'voted_logs' not in st.session_state: st.session_state['voted_logs'] = set()
+if "stopword_input_field" not in st.session_state: st.session_state["stopword_input_field"] = ""
+if "board_nick_input" not in st.session_state: st.session_state["board_nick_input"] = ""
+if "board_msg_input" not in st.session_state: st.session_state["board_msg_input"] = ""
+if "feedback_input_field" not in st.session_state: st.session_state["feedback_input_field"] = ""
+
+# -------------------------------------------------------------------------
+# 2. 헬퍼 함수 및 다이얼로그
+# -------------------------------------------------------------------------
+def format_saving(score, is_multi=False):
+    prefix = "총 " if is_multi else ""
+    if score > 0: return f"🟢 {prefix}+{score}단계 (절감)"
+    elif score < 0: return f"🔴 {prefix}{score}단계 (비쌈)"
+    else: return "⚪ 동일 수준"
+
+@st.dialog("🧠 AI 추천 알고리즘 작동 원리 상세", width="large")
+def show_logic_dialog():
+    if os.path.exists("flowchart.png"):
+        st.image("flowchart.png", use_container_width=True)
+    try:
+        with open("docs/logic_explanation.md", "r", encoding="utf-8") as f:
+            markdown_text = f.read()
+        st.markdown("---")
+        st.markdown(markdown_text)
+    except:
+        st.error("설명 파일을 찾을 수 없습니다.")
+
+@st.dialog("☁️ 검색 트렌드 워드클라우드", width="large")
+def show_wordcloud_dialog(timeframe_text, text_data):
+    st.subheader(f"{timeframe_text} 많이 검색된 타겟 재료")
+    if not text_data:
+        st.info("데이터가 충분하지 않습니다.")
+        return
+    font_path = "src/font.ttf" if os.path.exists("src/font.ttf") else None
+    try:
+        wordcloud = WordCloud(font_path=font_path, width=800, height=400, background_color='white', colormap='viridis', random_state=42).generate(text_data)
+        fig, ax = plt.subplots(figsize=(10, 5))
+        ax.imshow(wordcloud, interpolation='bilinear'); ax.axis('off')
+        st.pyplot(fig)
+        if not font_path: st.caption("⚠️ 한글 폰트 파일이 없어 글자가 깨질 수 있습니다.")
+    except Exception as e: st.error(f"오류 발생: {e}")
+
+# [NEW] 3D 벡터 공간 시각화 팝업
+@st.dialog("🌌 재료 벡터 공간 (3D Visualization)", width="large")
+def show_3d_space_dialog():
+    st.caption("AI가 학습한 재료들의 관계를 3차원 공간에서 확인해보세요. (상위 300개 재료)")
+    
+    try:
+        # logic.py에서 로드된 Word2Vec 모델 가져오기
+        model = logic.w2v_model
+        
+        # 빈도수 상위 300개 단어 추출
+        words = model.wv.index_to_key[:300]
+        vectors = np.array([model.wv[word] for word in words])
+        
+        # PCA로 100차원 -> 3차원 축소
+        pca = PCA(n_components=3)
+        projections = pca.fit_transform(vectors)
+        
+        # 데이터프레임 생성
+        df_vis = pd.DataFrame(projections, columns=['x', 'y', 'z'])
+        df_vis['word'] = words
+        
+        # Plotly 3D 산점도 그리기
+        fig = px.scatter_3d(
+            df_vis, x='x', y='y', z='z',
+            text='word',
+            hover_name='word',
+            color='z', # 높이에 따라 색상 변화
+            color_continuous_scale='Viridis'
+        )
+        
+        fig.update_traces(
+            marker=dict(size=4, opacity=0.8),
+            textposition='top center',
+            textfont=dict(size=10, color='black') # 텍스트 스타일
+        )
+        
+        fig.update_layout(
+            height=600,
+            scene=dict(
+                xaxis=dict(showticklabels=False, title=''),
+                yaxis=dict(showticklabels=False, title=''),
+                zaxis=dict(showticklabels=False, title='')
+            ),
+            margin=dict(l=0, r=0, b=0, t=0)
+        )
+        
+        st.plotly_chart(fig, use_container_width=True)
+        st.info("💡 **팁:** 마우스로 드래그하여 회전하거나 휠로 확대/축소할 수 있습니다. 가까이 있는 재료들은 AI가 '비슷한 성질'로 인식한 것입니다.")
+        
+    except Exception as e:
+        st.error(f"시각화 생성 실패: {e}")
+
+# [CALLBACK] 함수들
+def handle_board_submission():
+    nick = st.session_state.get("board_nick_input", "")
+    msg = st.session_state.get("board_msg_input", "")
+    if nick and msg:
+        if logic.save_board_message(nick, msg):
+            st.toast("게시글이 등록되었습니다!", icon="✅")
+            st.session_state["board_nick_input"] = ""
+            st.session_state["board_msg_input"] = ""
+        else: st.toast("게시글 등록에 실패했습니다.", icon="❌")
+    else: st.toast("닉네임과 내용을 모두 입력해주세요.", icon="⚠️")
+
+def handle_stopword_submission():
+    current_input = st.session_state.get("stopword_input_field", "")
+    if current_input:
+        is_success, msg = logic.save_stopwords_to_db(current_input)
+        if is_success:
+            st.toast(msg, icon="✅")
+            st.session_state["stopword_input_field"] = ""
+        else: st.toast(msg, icon="❌")
+    else: st.toast("단어를 입력해주세요.", icon="⚠️")
+
+def handle_feedback_submission():
+    content = st.session_state.get("feedback_input_field", "")
+    if content:
+        if logic.save_feedback_to_db(content):
+            st.toast("의견 감사합니다!", icon="✅")
+            st.balloons()
+            st.session_state["feedback_input_field"] = ""
+        else: st.toast("전송 실패", icon="❌")
+    else: st.toast("내용을 입력해주세요.", icon="⚠️")
+
+# -------------------------------------------------------------------------
+# 3. 사이드바 UI
+# -------------------------------------------------------------------------
+with st.sidebar:
+    st.header("🎛️ 컨트롤 패널")
+    selected_mode = st.radio("모드 선택", ["📚 Ver.1 기존 레시피 DB 검색", "✨ Ver.2 나만의 재료 입력 (커스텀)"], index=0)
+    st.divider()
+    st.subheader("⚖️ 가중치 설정")
+    is_v1 = selected_mode == "📚 Ver.1 기존 레시피 DB 검색"
+    w_w2v = st.slider("맛·성질 (Word2Vec)", 0.0, 5.0, 5.0, 0.5)
+    w_d2v = st.slider("문맥 (Doc2Vec)", 0.0, 5.0, 1.0, 0.5)
+    w_method = st.slider("조리법 통계 (Ver.1 전용)", 0.0, 5.0, 1.0, 0.5, disabled=not is_v1)
+    w_cat = st.slider("카테고리 통계 (Ver.1 전용)", 0.0, 5.0, 1.0, 0.5, disabled=not is_v1)
+    if not is_v1: st.caption("💡 커스텀 모드에서는 통계 가중치가 적용되지 않습니다.")
+    
+    excluded_ingredients = []
+    if not is_v1:
+        st.divider()
+        st.subheader("🚫 제외할 재료 설정")
+        all_ing_options = sorted(list(logic.all_ingredients_set))
+        excluded_ingredients = st.multiselect("제외할 재료 선택", all_ing_options, placeholder="예: 땅콩, 오이")
+    
+    st.divider()
+    # [NEW] 3D 시각화 버튼 추가
+    if st.button("🌌 재료 우주(3D) 탐험하기", use_container_width=True):
+        show_3d_space_dialog()
+        
+    if st.button("🤔 어떤 과정을 거쳐 재료가 추천되나요?", use_container_width=True):
+        show_logic_dialog()
+    
+    st.divider()
+    st.subheader("📊 인사이트 대시보드 (Beta)")
+    kst = timezone(timedelta(hours=9))
+    today_date_string = datetime.now(kst).strftime("%Y년 %m월 %d일")
+    stopwords_list = logic.load_global_stopwords()
+    
+    tab_today, tab_all = st.tabs(["📅 오늘", "📈 누적"])
+    
+    wc_text_today = logic.get_wordcloud_text('today')
+    wc_text_all = logic.get_wordcloud_text('all')
+    today_count, today_dishes, today_targets = logic.get_usage_stats(timeframe='today')
+    all_count, all_dishes, all_targets = logic.get_usage_stats(timeframe='all')
+
+    with tab_today:
+        st.caption(f"기준일: {today_date_string} (KST)")
+        col_m1, col_m2 = st.columns(2)
+        col_m1.metric("오늘 사용량", f"{today_count}건")
+        col_m2.metric("누적 불용어", f"{len(stopwords_list)}개")
+        if today_count > 0:
+            if st.button("☁️ 오늘의 워드클라우드", key="btn_wc_today", use_container_width=True):
+                show_wordcloud_dialog("오늘", wc_text_today)
+            st.caption("🔥 오늘 많이 대체된 재료")
+            if not today_targets.empty: st.bar_chart(today_targets, color="#FF6B6B", height=200)
+        else: st.info("오늘의 데이터가 없습니다.")
+
+    with tab_all:
+        st.caption("서비스 시작 이후 전체 데이터")
+        col_a1, col_a2 = st.columns(2)
+        col_a1.metric("총 사용량", f"{all_count}건")
+        col_a2.metric("누적 불용어", f"{len(stopwords_list)}개")
+        if all_count > 0:
+            if st.button("☁️ 누적 워드클라우드", key="btn_wc_all", use_container_width=True):
+                show_wordcloud_dialog("누적", wc_text_all)
+            st.caption("🔥 역대 많이 대체된 재료")
+            if not all_targets.empty: st.bar_chart(all_targets, color="#FF6B6B", height=200)
+        else: st.info("누적 데이터가 없습니다.")
+
+    with st.expander("📋 신고된 불용어 목록 보기"):
+        if stopwords_list: st.dataframe(pd.DataFrame(stopwords_list, columns=["불용어"]), use_container_width=True, hide_index=True)
+        else: st.info("신고된 불용어가 없습니다.")
+            
+    st.divider()
+    with st.expander("💬 익명 게시판 (Beta)", expanded=True):
+        with st.form("board_form"):
+            st.text_input("닉네임", placeholder="익명", key="board_nick_input")
+            st.text_area("내용", placeholder="자유롭게 의견을 남겨주세요", height=80, key="board_msg_input")
+            st.form_submit_button("등록", on_click=handle_board_submission)
+        
+        st.markdown("---")
+        messages = logic.get_board_messages()
+        if messages:
+            for m in messages:
+                st.markdown(f"**{m['nickname']}** <span style='color:grey; font-size:0.8em;'>({m['display_time']})</span>", unsafe_allow_html=True)
+                st.text(m['content'])
+                st.divider()
+        else: st.caption("첫 번째 글을 남겨보세요!")
+
+# -------------------------------------------------------------------------
+# 4. 메인 UI (기존과 동일)
+# -------------------------------------------------------------------------
+col_main, _ = st.columns([0.9, 0.1])
+with col_main:
+    if selected_mode == "📚 Ver.1 기존 레시피 DB 검색":
+        st.markdown("""<div style="background-color: #f0f8ff; padding: 15px; border-radius: 10px; margin-bottom: 20px;"><h4 style="margin:0; color:#0066cc;">[Ver.1] 레시피 데이터베이스에서 검색</h4><p style="margin:5px 0 0 0; font-size:14px;">학습된 12만여 개의 레시피 중 하나를 선택하여 분석합니다. 모든 통계 점수가 활용됩니다.</p></div>""", unsafe_allow_html=True)
+        search_keyword = st.text_input("🍽️ 요리명 검색 (키워드 입력 후 엔터)", placeholder="예: 된장찌개")
+        final_dish_name = None
+        if search_keyword:
+            exact_match = logic.df[logic.df['요리명'] == search_keyword]
+            exact_name = exact_match['요리명'].iloc[0] if not exact_match.empty else None
+            candidates = logic.df[logic.df['요리명'].str.contains(search_keyword, na=False, case=False)]
+            if exact_name: candidates = candidates[candidates['요리명'] != exact_name]
+            candidate_names = sorted(candidates['요리명'].unique().tolist())[:30]
+            options = []
+            if exact_name: options.append(exact_name)
+            options.extend(candidate_names)
+            if not options: st.warning(f"🔍 '{search_keyword}'가 포함된 요리명을 찾을 수 없습니다.")
+            else:
+                index_to_select = 0 if exact_name else None
+                label_msg = f"🔎 '{search_keyword}' 검색 결과 ({len(options)}개)"
+                if exact_name: label_msg += " - 정확한 요리명이 발견되었습니다!"
+                selected_option = st.selectbox(label_msg, options, index=index_to_select)
+                final_dish_name = selected_option
+        if final_dish_name:
+            st.success(f"✅ 선택된 요리: **{final_dish_name}**")
+            cands = logic.df[logic.df['요리명'] == final_dish_name]
+            cands = cands.head(10).reset_index(drop=True)
+            if cands.empty: st.error("❌ 레시피 정보를 불러올 수 없습니다.")
+            else:
+                st.divider()
+                options = {}
+                for _, r in cands.iterrows():
+                    preview = ', '.join(r['재료토큰'])
+                    options[f"[{r['요리방법별명']}] {r['요리명']} (ID:{r['레시피일련번호']}) - {preview}"] = r['레시피일련번호']
+                selected_label = st.selectbox("📜 분석할 레시피를 선택하세요", list(options.keys()))
+                recipe_id = options[selected_label]
+                c1, c2 = st.columns(2)
+                with c1: target_str = st.text_input("🎯 바꿀 재료", placeholder="돼지고기, 양파")
+                with c2: stop_str = st.text_input("🚫 제거할 문구", placeholder="약간, 시판용")
+                if target_str:
+                    targets = [t.strip() for t in target_str.split(',') if t.strip()]
+                    stops = [s.strip() for s in stop_str.split(',') if s.strip()]
+                    current_recipe_row = logic.df[logic.df['레시피일련번호'] == recipe_id].iloc[0]
+                    recipe_ingredients = current_recipe_row['재료토큰']
+                    invalid_targets = [t for t in targets if t not in recipe_ingredients]
+                    if not targets: st.warning("타겟 재료를 입력해주세요.")
+                    elif invalid_targets:
+                        st.error(f"🚨 다음 재료는 선택한 레시피에 없습니다: {', '.join(invalid_targets)}")
+                        st.info("💡 팁: 레시피 미리보기에 있는 재료명을 정확히 입력해주세요.")
+                    else:
+                        st.divider()
+                        has_result = False
+                        final_recs = []
+                        if len(targets) == 1:
+                            st.subheader("🔹 단일 재료 대체 추천 (DB 기반)")
+                            t = targets[0]
+                            res = logic.substitute_single(recipe_id, t, stops, w_w2v, w_d2v, w_method, w_cat, topn=5)
+                            st.markdown(f"**{t}** 대체 결과")
+                            if not res.empty:
+                                has_result = True
+                                final_recs = res['대체재료'].head(3).tolist()
+                                d_df = res[['대체재료', '최종점수', 'saving_score']].copy()
+                                d_df['예상 원가변동'] = d_df['saving_score'].apply(lambda x: format_saving(x))
+                                d_df = d_df[['대체재료', '최종점수', '예상 원가변동']]
+                                d_df.columns = ['추천재료', '적합도', '예상 원가변동']
+                                st.dataframe(d_df.style.format("{:.1%}", subset=['적합도']).background_gradient(cmap='Greens', subset=['적합도']), use_container_width=True, hide_index=True)
+                            else: st.warning("결과 없음")
+                        elif len(targets) > 1:
+                            st.subheader("🧩 최적의 재료 조합 (DB 기반 다중 대체)")
+                            multi_res = logic.substitute_multi(recipe_id, targets, stops, w_w2v, w_d2v, w_method, w_cat)
+                            if multi_res:
+                                has_result = True
+                                final_recs = [", ".join(subs) for subs, score, saving in multi_res]
+                                m_df = pd.DataFrame([(f"{', '.join(subs)}", score, format_saving(saving, True)) for subs, score, saving in multi_res], columns=['추천 조합', '종합 점수', '예상 원가변동 합계'])
+                                st.dataframe(m_df.style.format("{:.1%}", subset=['종합 점수']).background_gradient(cmap='Blues', subset=['종합 점수']), use_container_width=True, hide_index=True)
+                            else: st.info("조합을 찾을 수 없습니다.")
+                        if has_result:
+                            current_state = f"DB_{final_dish_name}_{target_str}_{stop_str}_{w_w2v}_{w_d2v}_{w_method}_{w_cat}_{final_recs}"
+                            if 'last_log' not in st.session_state: st.session_state['last_log'] = ""
+                            if st.session_state['last_log'] != current_state:
+                                log_id = logic.save_log_to_db(final_dish_name, target_str, stops, w_w2v, w_d2v, w_method, w_cat, rec_list=final_recs, is_custom=False)
+                                st.session_state['current_log_id'] = log_id
+                                st.session_state['last_log'] = current_state
+                            if 'current_log_id' in st.session_state and st.session_state['current_log_id']:
+                                cl_id = st.session_state['current_log_id']
+                                is_voted = cl_id in st.session_state['voted_logs']
+                                st.write(""); b1, b2, _ = st.columns([0.2, 0.2, 0.6])
+                                if is_voted: b1.success("✅ 평가 완료!"); b2.write("")
+                                else:
+                                    b1.button("👍 만족해요", key="btn_sat_db", use_container_width=True, on_click=lambda: (logic.update_feedback_in_db(cl_id, "satisfy"), st.session_state['voted_logs'].add(cl_id), st.toast("감사합니다!")))
+                                    b2.button("👎 아쉬워요", key="btn_dis_db", use_container_width=True, on_click=lambda: (logic.update_feedback_in_db(cl_id, "dissatisfy"), st.session_state['voted_logs'].add(cl_id), st.toast("의견 감사합니다.")))
+
+    elif selected_mode == "✨ Ver.2 나만의 재료 입력 (커스텀)":
+        st.markdown("""<div style="background-color: #fff5f0; padding: 15px; border-radius: 10px; margin-bottom: 20px;"><h4 style="margin:0; color:#cc5500;">[Ver.2] 나만의 재료 리스트 입력</h4><p style="margin:5px 0 0 0; font-size:14px;">냉장고 속 재료들을 직접 입력하세요. 문맥을 실시간으로 분석하여 추천합니다. (통계 점수 제외)</p></div>""", unsafe_allow_html=True)
+        st.markdown("##### 🏷️ 요리명 입력 (참고용)")
+        search_keyword_v2 = st.text_input("키워드 입력 후 엔터 (예: 볶음밥) - 선택사항", key="v2_search")
+        custom_dish_name = search_keyword_v2
+        if search_keyword_v2:
+            exact_match_v2 = logic.df[logic.df['요리명'] == search_keyword_v2]
+            exact_name_v2 = exact_match_v2['요리명'].iloc[0] if not exact_match_v2.empty else None
+            candidates_v2 = logic.df[logic.df['요리명'].str.contains(search_keyword_v2, na=False, case=False)]
+            if exact_name_v2: candidates_v2 = candidates_v2[candidates_v2['요리명'] != exact_name_v2]
+            candidate_names_v2 = sorted(candidates_v2['요리명'].unique().tolist())[:30]
+            options_v2 = []
+            if exact_name_v2: options_v2.append(exact_name_v2)
+            options_v2.append("(직접 입력한 이름 사용)")
+            options_v2.extend(candidate_names_v2)
+            if options_v2:
+                idx_v2 = 0 if exact_name_v2 else 0
+                label_v2 = f"💡 관련 요리명 발견 ({len(options_v2)-1}개)"
+                if exact_name_v2: label_v2 += " - 정확한 요리명 발견!"
+                sel_v2 = st.selectbox(label_v2, options_v2, index=idx_v2, key="v2_select")
+                if sel_v2 != "(직접 입력한 이름 사용)": custom_dish_name = sel_v2
+        
+        st.write("")
+        context_str = st.text_area("📝 전체 재료 리스트 (쉼표로 구분)", placeholder="예: 밥, 계란, 대파, 간장, 참기름", height=100, key="v2_context")
+        if context_str:
+            context_ings_list = [ing.strip() for ing in context_str.split(',') if ing.strip()]
+            if not context_ings_list: st.warning("재료를 한 개 이상 입력해주세요.")
+            else:
+                st.caption(f"인식된 재료 ({len(context_ings_list)}개): {', '.join(context_ings_list)}")
+                c1_c, c2_c = st.columns(2)
+                with c1_c: target_str_c = st.text_input("🎯 바꿀 재료 (위 리스트 중)", placeholder="예: 계란", key="v2_target")
+                with c2_c: stop_str_c = st.text_input("🚫 제거할 문구 (임시)", placeholder="예: 약간", key="v2_stop")
+                if target_str_c:
+                    targets_c = [t.strip() for t in target_str_c.split(',') if t.strip()]
+                    stops_c = [s.strip() for s in stop_str_c.split(',') if s.strip()]
+                    invalid_targets = [t for t in targets_c if t not in context_ings_list]
+                    if invalid_targets: st.error(f"🚨 다음 재료는 전체 리스트에 없습니다: {', '.join(invalid_targets)}")
+                    elif not targets_c: st.warning("바꿀 재료를 입력해주세요.")
+                    else:
+                        st.divider()
+                        has_result_c = False
+                        final_recs_c = []
+                        if len(targets_c) == 1:
+                            st.subheader("🔹 단일 재료 대체 추천 (커스텀)")
+                            t_c = targets_c[0]
+                            res_c = logic.substitute_single_custom(t_c, context_ings_list, stops_c, w_w2v, w_d2v, excluded_ings=excluded_ingredients, topn=5)
+                            st.markdown(f"**{t_c}** 대체 결과")
+                            if not res_c.empty:
+                                has_result_c = True
+                                final_recs_c = res_c['대체재료'].head(3).tolist()
+                                d_df_c = res_c[['대체재료', '최종점수', 'saving_score']].copy()
+                                d_df_c['예상 원가변동'] = d_df_c['saving_score'].apply(lambda x: format_saving(x))
+                                d_df_c = d_df_c[['대체재료', '최종점수', '예상 원가변동']]
+                                d_df_c.columns = ['추천재료', '적합도', '예상 원가변동']
+                                st.dataframe(d_df_c.style.format("{:.1%}", subset=['적합도']).background_gradient(cmap='Greens', subset=['적합도']), use_container_width=True, hide_index=True)
+                            else: st.warning("결과 없음")
+                        elif len(targets_c) > 1:
+                            st.subheader("🧩 최적의 재료 조합 (커스텀 다중 대체)")
+                            multi_res_c = logic.substitute_multi_custom(targets_c, context_ings_list, stops_c, w_w2v, w_d2v, excluded_ings=excluded_ingredients)
+                            if multi_res_c:
+                                has_result_c = True
+                                final_recs_c = [", ".join(subs) for subs, score, saving in multi_res_c]
+                                m_df_c = pd.DataFrame([(f"{', '.join(subs)}", score, format_saving(saving, True)) for subs, score, saving in multi_res_c], columns=['추천 조합', '종합 점수', '예상 원가변동 합계'])
+                                st.dataframe(m_df_c.style.format("{:.1%}", subset=['종합 점수']).background_gradient(cmap='Blues', subset=['종합 점수']), use_container_width=True, hide_index=True)
+                            else: st.info("조합을 찾을 수 없습니다.")
+                        if has_result_c:
+                            current_state_c = f"Custom_{custom_dish_name}_{target_str_c}_{stop_str_c}_{w_w2v}_{w_d2v}_{final_recs_c}"
+                            if 'last_log_c' not in st.session_state: st.session_state['last_log_c'] = ""
+                            if st.session_state['last_log_c'] != current_state_c:
+                                log_id_c = logic.save_log_to_db(custom_dish_name, target_str_c, stops_c, w_w2v, w_d2v, 0, 0, rec_list=final_recs_c, is_custom=True)
+                                st.session_state['current_log_id_c'] = log_id_c
+                                st.session_state['last_log_c'] = current_state_c
+                            if 'current_log_id_c' in st.session_state and st.session_state['current_log_id_c']:
+                                cl_id_c = st.session_state['current_log_id_c']
+                                is_voted_c = cl_id_c in st.session_state['voted_logs']
+                                st.write(""); b1_c, b2_c, _ = st.columns([0.2, 0.2, 0.6])
+                                if is_voted_c: b1_c.success("✅ 평가 완료!"); b2_c.write("")
+                                else:
+                                    b1_c.button("👍 만족해요", key="btn_sat_custom", use_container_width=True, on_click=lambda: (logic.update_feedback_in_db(cl_id_c, "satisfy"), st.session_state['voted_logs'].add(cl_id_c), st.toast("감사합니다!")))
+                                    b2_c.button("👎 아쉬워요", key="btn_dis_custom", use_container_width=True, on_click=lambda: (logic.update_feedback_in_db(cl_id_c, "dissatisfy"), st.session_state['voted_logs'].add(cl_id_c), st.toast("의견 감사합니다.")))
+        else: st.info("👆 전체 재료 리스트를 먼저 입력해주세요.")
+
+# -------------------------------------------------------------------------
+# 5. 하단 피드백 및 불용어 신고 영역
+# -------------------------------------------------------------------------
+st.divider()
+col_feedback, col_stopword = st.columns(2)
+
+with col_feedback:
+    st.subheader("📢 서비스 의견 보내기")
+    with st.form("feedback_form"):
+        text = st.text_area("개선할 점이나 버그가 있다면 알려주세요!", height=100, key="feedback_input_field")
+        st.form_submit_button("의견 보내기", use_container_width=True, on_click=handle_feedback_submission)
+
+with col_stopword:
+    st.subheader("🚫 불용어(이상한 단어) 신고하기")
+    st.caption(
+        "추천 결과에 이상한 단어가 있나요? 신고해주시면 다음부터 제외됩니다.",
+        help="현재 학습 데이터에 포함된 불용어가 너무 많아 일일이 수작업으로 처리하기 어렵습니다. 😥 여러분의 신고가 모이면 데이터의 품질이 높아지고 추천 결과도 더 정확해집니다. 소중한 기여 부탁드립니다! 🙏"
+    )
+    st.info("💡 Tip: '간장or진간장' 같은 경우 'or'를 신고하면 '간장진간장'으로 합쳐져 추천에서 제외됩니다.")
+    
+    with st.form("stopword_form"):
+        st.text_input("신고할 단어 입력 (쉼표로 구분)", placeholder="예: 면포, 황석어젓, 텃밭", key="stopword_input_field")
+        st.form_submit_button("신고하기", use_container_width=True, on_click=handle_stopword_submission)

src/logic.py

@@ -0,0 +1,639 @@
+# logic.py
+import streamlit as st
+import pandas as pd
+import numpy as np
+from gensim.models import Word2Vec, Doc2Vec
+from ast import literal_eval
+import pickle
+from datetime import datetime, timedelta, timezone
+from supabase import create_client
+import re
+from collections import Counter
+
+# ==========================================
+# 0. 환경 설정 및 규칙 정의
+# ==========================================
+PRICE_KEYWORD_RULES = [
+    (5, ['소고기', '한우', '채끝', '등심', '안심', '갈비살', '전복', '장어']),
+    (4, ['돼지', '삼겹', '목살', '앞다리', '뒷다리', '갈비', '오리', '낙지', '오징어', '새우', '명란']),
+    (3, ['닭', '치킨', '햄', '소시지', '베이컨', '스팸', '참치', '동원', '어묵', '맛살', '버섯', '치즈']),
+    (2, ['두부', '순두부', '콩나물', '숙주', '김치', '무', '감자', '고구마', '당근', '호박']),
+    (1, ['양파', '대파', '쪽파', '실파', '마늘', '고추', '물', '소금', '설탕', '간장', '소스', '양념', '육수'])
+]
+PRICE_RULE_EXCEPTIONS = ['돼지감자', '닭의장풀', '새우젓', '멸치액젓', '다시다']
+
+# ==========================================
+# 1. Supabase DB 연동 및 데이터 저장/로드
+# ==========================================
+@st.cache_resource
+def init_supabase():
+    try:
+        url = None
+        key = None
+        
+        # 1. Try Streamlit secrets
+        try:
+            if hasattr(st, "secrets") and "supabase" in st.secrets:
+                url = st.secrets["supabase"]["url"]
+                key = st.secrets["supabase"]["key"]
+        except:
+            pass
+            
+        # 2. Add fallback to OS environment variables
+        if not url or not key:
+            url = os.environ.get("SUPABASE_URL")
+            key = os.environ.get("SUPABASE_KEY")
+            
+        if not url or not key:
+            # 로컬 개발 중 secrets 없이 실행될 경우를 대비해 스킵하거나 에러 처리
+            # API 서버에서는 필수이므로 로그 남김
+            return None
+
+        return create_client(url, key)
+    except Exception as e:
+        print(f"Supabase 연결 경고: {e}")
+        return None
+
+def get_kst_now_iso():
+    kst_timezone = timezone(timedelta(hours=9))
+    now_kst = datetime.now(kst_timezone)
+    return now_kst.isoformat()
+
+@st.cache_data(ttl=300)
+def load_global_stopwords():
+    try:
+        supabase = init_supabase()
+        response = supabase.table("stopwords").select("word").order("created_at", desc=True).execute()
+        if response.data:
+            return [item['word'] for item in response.data]
+        return []
+    except Exception as e:
+        print(f"불용어 로드 실패: {e}")
+        return []
+
+@st.cache_data(ttl=600)
+def get_usage_stats(timeframe='today'):
+    try:
+        supabase = init_supabase()
+        query = supabase.table("usage_log").select("dish, target")
+
+        if timeframe == 'today':
+            kst = timezone(timedelta(hours=9))
+            now_kst = datetime.now(kst)
+            today_start = now_kst.replace(hour=0, minute=0, second=0, microsecond=0)
+            tomorrow_start = today_start + timedelta(days=1)
+            query = query.gte("created_at", today_start.isoformat()).lt("created_at", tomorrow_start.isoformat())
+        
+        response = query.execute()
+        data = response.data
+        
+        count = len(data)
+        top_dishes = pd.Series(dtype=int)
+        top_targets = pd.Series(dtype=int)
+
+        if count > 0:
+            df_log = pd.DataFrame(data)
+            df_log['clean_dish'] = df_log['dish'].astype(str).str.replace(r'\[Custom\]', '', regex=True).str.strip()
+            top_dishes = df_log[df_log['clean_dish'] != '']['clean_dish'].value_counts().head(5)
+
+            all_targets = []
+            for t in df_log['target']:
+                if t:
+                    all_targets.extend([x.strip() for x in str(t).split(',') if x.strip()])
+            top_targets = pd.Series(all_targets).value_counts().head(5)
+
+        return count, top_dishes, top_targets
+
+    except Exception as e:
+        print(f"통계 데이터 로드 실패 ({timeframe}): {e}")
+        return 0, pd.Series(dtype=int), pd.Series(dtype=int)
+
+@st.cache_data(ttl=600)
+def get_wordcloud_text(timeframe='today'):
+    try:
+        supabase = init_supabase()
+        query = supabase.table("usage_log").select("target")
+        if timeframe == 'today':
+            kst = timezone(timedelta(hours=9))
+            now_kst = datetime.now(kst)
+            today_start = now_kst.replace(hour=0, minute=0, second=0, microsecond=0)
+            tomorrow_start = today_start + timedelta(days=1)
+            query = query.gte("created_at", today_start.isoformat()).lt("created_at", tomorrow_start.isoformat())
+        
+        response = query.execute()
+        data = response.data
+        all_targets = []
+        if data:
+            for item in data:
+                if item['target']:
+                    all_targets.extend([x.strip() for x in str(item['target']).split(',') if x.strip()])
+        return " ".join(all_targets)
+    except Exception as e:
+        print(f"워드클라우드 데이터 로드 실패: {e}")
+        return ""
+
+def save_stopwords_to_db(words_string):
+    words = [w.strip() for w in words_string.split(',') if w.strip()]
+    if not words: return False, "저장할 단어가 없습니다."
+    supabase = init_supabase()
+    success_count, duplicate_count, fail_count = 0, 0, 0
+    for word in words:
+        try:
+            supabase.table("stopwords").insert({"word": word}).execute()
+            success_count += 1
+        except Exception as e:
+            if 'duplicate' in str(e).lower(): duplicate_count += 1
+            else: fail_count += 1
+    if success_count > 0: st.cache_data.clear()
+    msg_parts = []
+    if success_count > 0: msg_parts.append(f"✅ {success_count}개 저장")
+    if duplicate_count > 0: msg_parts.append(f"⚠️ {duplicate_count}개 중복")
+    if fail_count > 0: msg_parts.append(f"❌ {fail_count}개 실패")
+    return success_count > 0, ", ".join(msg_parts)
+
+@st.cache_data(ttl=60) 
+def get_board_messages():
+    try:
+        supabase = init_supabase()
+        response = supabase.table("board").select("*").order("created_at", desc=True).limit(50).execute()
+        if response.data:
+            for item in response.data:
+                dt = datetime.fromisoformat(item['created_at'])
+                dt_kst = dt + timedelta(hours=9) 
+                item['display_time'] = dt_kst.strftime("%m/%d %H:%M")
+            return response.data
+        return []
+    except Exception as e:
+        print(f"게시판 로드 실패: {e}")
+        return []
+
+def save_board_message(nickname, content):
+    if not nickname or not content: return False
+    try:
+        supabase = init_supabase()
+        supabase.table("board").insert({"nickname": nickname, "content": content}).execute()
+        st.cache_data.clear()
+        return True
+    except Exception as e:
+        print(f"게시판 저장 실패: {e}")
+        return False
+
+def save_feedback_to_db(feedback_text):
+    try:
+        supabase = init_supabase()
+        supabase.table("feedback").insert({"content": feedback_text, "created_at": get_kst_now_iso()}).execute()
+        return True
+    except Exception as e:
+        print(f"피드백 저장 에러: {e}")
+        return False
+
+def save_log_to_db(dish, target, stops, w1, w2, w3, w4, rec_list=None, is_custom=False):
+    try:
+        supabase = init_supabase()
+        r1 = rec_list[0] if rec_list and len(rec_list) > 0 else None
+        r2 = rec_list[1] if rec_list and len(rec_list) > 1 else None
+        r3 = rec_list[2] if rec_list and len(rec_list) > 2 else None
+        dish_name_to_save = f"[Custom] {dish}" if is_custom else dish
+        data = {
+            "dish": dish_name_to_save, "target": target, "stops": ", ".join(stops) if stops else "없음",
+            "w_w2v": w1, "w_d2v": w2, "w_method": w3, "w_cat": w4, "rec_1": r1, "rec_2": r2, "rec_3": r3,
+            "created_at": get_kst_now_iso()
+        }
+        response = supabase.table("usage_log").insert(data).execute()
+        if response.data: return response.data[0]['id']
+        return None
+    except Exception as e:
+        print(f"로그 저장 에러: {e}")
+        return None
+
+def update_feedback_in_db(log_id, status):
+    try:
+        supabase = init_supabase()
+        if log_id:
+            supabase.table("usage_log").update({"satisfaction": status}).eq("id", log_id).execute()
+            return True
+        return False
+    except Exception as e:
+        print(f"만족도 업데이트 에러: {e}")
+        return False
+
+# ==========================================
+# 2. 데이터 및 모델 로드
+# ==========================================
+# ==========================================
+# 2. 데이터 및 모델 로드 (Lazy Loading 적용)
+# ==========================================
+w2v_model = None
+d2v_model = None
+df = None
+stats = None
+price_map = {}
+global_stopwords_set = set()
+all_ingredients_set = set()
+method_map = {}
+recipes_by_ingredient = {}
+ing_method_counts = {}
+ing_cat_counts = {}
+total_method_counts = {}
+total_cat_counts = {}
+TOTAL_RECIPES = 0
+
+def load_resources():
+    global w2v_model, d2v_model, df, stats, price_map, global_stopwords_set, all_ingredients_set
+    global method_map, recipes_by_ingredient, ing_method_counts, ing_cat_counts, total_method_counts, total_cat_counts, TOTAL_RECIPES
+    
+    print("Loading resources... (This may take a while)")
+    # mmap='r' 옵션으로 메모리 사용량 최소화 (디스크에서 직접 읽음)
+    w2v_model = Word2Vec.load("models/w2v.model", mmap='r')
+    d2v_model = Doc2Vec.load("models/d2v.model", mmap='r')
+    df_temp = pd.read_csv("data/final_recipe_data.csv")
+    df_temp['재료토큰'] = df_temp['재료토큰'].apply(literal_eval)
+    df = df_temp # Assign to global
+    
+    with open("data/stats.pkl", "rb") as f:
+        stats = pickle.load(f)
+        
+    try:
+        price_df = pd.read_csv("data/price_rank.csv", encoding='utf-8-sig')
+        price_df.columns = price_df.columns.str.strip()
+        price_map = dict(zip(price_df['ingredient'], price_df['rank']))
+    except:
+        price_map = {}
+    
+    global_stopwords_set = set() 
+    all_ingredients_set = set()
+    for ings in df['재료토큰']:
+        all_ingredients_set.update(ings)
+        
+    # Stats unpacking
+    method_map = stats["method_map"]
+    recipes_by_ingredient = stats["recipes_by_ingredient"]
+    ing_method_counts = stats["ing_method_counts"]
+    ing_cat_counts = stats["ing_cat_counts"]
+    total_method_counts = stats["total_method_counts"]
+    total_cat_counts = stats["total_cat_counts"]
+    TOTAL_RECIPES = stats["TOTAL_RECIPES"]
+    print("Resources loaded successfully!")
+
+def ensure_initialized():
+    if df is None:
+        load_resources()
+
+# 기존 즉시 실행 코드 제거
+# w2v_model, d2v_model, ... = load_resources()
+
+# ==========================================
+# 3. 핵심 계산 로직
+# ==========================================
+def cos_sim(vec_a, vec_b):
+    norm = (np.linalg.norm(vec_a) * np.linalg.norm(vec_b) + 1e-9)
+    return max(0.0, float(np.dot(vec_a, vec_b) / norm))
+
+def get_stat_score(ingredient, target_key, ing_count_dict, total_count_dict, total_n, min_count=5):
+    cnts = ing_count_dict.get(ingredient)
+    if not cnts: return 0.0
+    ing_target_count = cnts[target_key]
+    ing_total_count = sum(cnts.values())
+    if ing_total_count < min_count: return 0.0
+    prob_ing_context = ing_target_count / ing_total_count
+    baseline_prob = total_count_dict[target_key] / total_n
+    if baseline_prob == 0: return 0.0
+    return prob_ing_context / baseline_prob
+
+def get_estimated_price_rank(ing_name, price_map):
+    if ing_name in price_map: return price_map[ing_name]
+    if any(exp in ing_name for exp in PRICE_RULE_EXCEPTIONS): return 3
+    for rank, keywords in PRICE_KEYWORD_RULES:
+        if any(kw in ing_name for kw in keywords): return rank
+    return 3
+
+# ==========================================
+# 4. 대체 추천 알고리즘 (DB 기반)
+# ==========================================
+def substitute_single(recipe_id, target_ing, user_stopwords, w_w2v, w_d2v, w_method, w_cat, topn=10):
+    row = df[df['레시피일련번호'] == recipe_id].iloc[0]
+    current_method = row['요리방법별명']
+    current_cat = row['요리종류별명_세분화']
+    context_ings = row['재료토큰']
+    tag = f"recipe_{recipe_id}"
+    if target_ing not in w2v_model.wv: return pd.DataFrame()
+    total_weight = w_w2v + w_d2v + w_method + w_cat
+    if total_weight == 0: total_weight = 1.0
+    vec_recipe = None
+    if w_d2v > 0 and tag in d2v_model.dv: vec_recipe = d2v_model.dv[tag]
+    target_rank = get_estimated_price_rank(target_ing, price_map)
+    candidates_raw = w2v_model.wv.most_similar(target_ing, topn=50)
+    temp_results = []
+    seen_candidates = set()
+    
+    # [수정] 실시간 로드
+    global_stopwords_set = set(load_global_stopwords())
+    final_stopwords = set(user_stopwords) | global_stopwords_set
+
+    for cand, score_w2v in candidates_raw:
+        clean_cand = cand
+        if final_stopwords:
+            for stop in final_stopwords: clean_cand = clean_cand.replace(stop, "")
+        clean_cand = clean_cand.strip()
+        
+        if not clean_cand: continue
+        if clean_cand in final_stopwords: continue
+
+        if clean_cand in context_ings: continue
+        if clean_cand == target_ing: continue
+        if clean_cand not in w2v_model.wv: continue
+        if clean_cand in seen_candidates: continue
+        seen_candidates.add(clean_cand)
+        real_score_w2v = w2v_model.wv.similarity(target_ing, clean_cand)
+        s_w2v = max(0.0, real_score_w2v)
+        if s_w2v < 0.35: continue
+        s_d2v = 0.0
+        if w_d2v > 0 and vec_recipe is not None:
+            rid_list = recipes_by_ingredient.get(clean_cand, [])
+            same_method_ids = [r for r in rid_list if method_map.get(r) == current_method]
+            if len(same_method_ids) > 20:
+                np.random.seed(42)
+                same_method_ids = np.random.choice(same_method_ids, 20, replace=False)
+            if same_method_ids is not None and len(same_method_ids) > 0:
+                sims = []
+                for r in same_method_ids:
+                    rt = f"recipe_{r}"
+                    if rt in d2v_model.dv: sims.append(cos_sim(vec_recipe, d2v_model.dv[rt]))
+                if sims: s_d2v = np.mean(sims)
+        s_method = 0.0 if w_method <= 0 else get_stat_score(clean_cand, current_method, ing_method_counts, total_method_counts, TOTAL_RECIPES)
+        s_cat = 0.0 if w_cat <= 0 else get_stat_score(clean_cand, current_cat, ing_cat_counts, total_cat_counts, TOTAL_RECIPES)
+        cand_rank = get_estimated_price_rank(clean_cand, price_map)
+        saving_score = target_rank - cand_rank
+        temp_results.append({"대체재료": clean_cand, "raw_W2V": s_w2v, "raw_D2V": s_d2v, "raw_Method": s_method, "raw_Category": s_cat, "saving_score": saving_score})
+    if not temp_results: return pd.DataFrame()
+    df_res = pd.DataFrame(temp_results)
+    cols = ["raw_W2V", "raw_D2V", "raw_Method", "raw_Category"]
+    norm_cols = ["W2V", "D2V", "Method", "Category"]
+    for raw_col, norm_col in zip(cols, norm_cols):
+        min_val = df_res[raw_col].min()
+        max_val = df_res[raw_col].max()
+        if max_val - min_val == 0: df_res[norm_col] = 0.5
+        else: df_res[norm_col] = (df_res[raw_col] - min_val) / (max_val - min_val)
+    df_res["최종점수"] = ((df_res["W2V"]*w_w2v) + (df_res["D2V"]*w_d2v) + (df_res["Method"]*w_method) + (df_res["Category"]*w_cat)) / total_weight
+    return df_res.sort_values("최종점수", ascending=False).head(topn).reset_index(drop=True)
+
+def substitute_multi(recipe_id, targets, user_stopwords, w_w2v, w_d2v, w_method, w_cat, beam_width=3, result_topn=3):
+    row = df[df['레시피일련번호'] == recipe_id].iloc[0]
+    current_method = row['요리방법별명']
+    current_cat = row['요리종류별명_세분화']
+    initial_context = row['재료토큰']
+    tag = f"recipe_{recipe_id}"
+    vec_recipe = None
+    if w_d2v > 0 and tag in d2v_model.dv: vec_recipe = d2v_model.dv[tag]
+    total_weight = w_w2v + w_d2v + w_method + w_cat
+    if total_weight == 0: total_weight = 1.0
+    target_ranks_sum = 0
+    for t in targets: target_ranks_sum += get_estimated_price_rank(t, price_map)
+    
+    # [수정] 실시간 로드
+    global_stopwords_set = set(load_global_stopwords())
+    final_stopwords = set(user_stopwords) | global_stopwords_set
+
+    beam = [(0.0, [], initial_context)]
+    for target_ing in targets:
+        next_beam = []
+        if target_ing not in w2v_model.wv:
+            for score, subs, ctx in beam: next_beam.append((score, subs + [target_ing], ctx))
+            beam = next_beam
+            continue
+        for path_score, path_subs, path_ctx in beam:
+            current_ctx_ing = [x for x in path_ctx if x != target_ing]
+            candidates = w2v_model.wv.most_similar(target_ing, topn=30)
+            temp_candidates = []
+            seen_candidates = set()
+            for cand, _ in candidates:
+                clean_cand = cand
+                if final_stopwords:
+                    for stop in final_stopwords: clean_cand = clean_cand.replace(stop, "")
+                clean_cand = clean_cand.strip()
+
+                if not clean_cand: continue
+                if clean_cand in final_stopwords: continue
+
+                if clean_cand in current_ctx_ing or clean_cand in path_subs: continue
+                if clean_cand == target_ing: continue
+                if clean_cand not in w2v_model.wv: continue
+                if clean_cand in seen_candidates: continue
+                seen_candidates.add(clean_cand)
+                sim_orig = w2v_model.wv.similarity(target_ing, clean_cand)
+                sim_orig = max(0.0, sim_orig)
+                if sim_orig < 0.3: continue
+                harmony_scores = [w2v_model.wv.similarity(clean_cand, c) for c in current_ctx_ing if c in w2v_model.wv]
+                sim_harmony = np.mean(harmony_scores) if harmony_scores else 0.0
+                s_w2v = 0.5 * sim_orig + 0.5 * max(0.0, sim_harmony)
+                s_d2v = 0.0
+                if vec_recipe is not None:
+                    rid_list = recipes_by_ingredient.get(clean_cand, [])
+                    same_method_ids = [r for r in rid_list if method_map.get(r) == current_method]
+                    if len(same_method_ids) > 10:
+                        np.random.seed(42)
+                        same_method_ids = np.random.choice(same_method_ids, 10, replace=False)
+                    if same_method_ids is not None and len(same_method_ids) > 0:
+                        sims = []
+                        for r in same_method_ids:
+                            rt = f"recipe_{r}"
+                            if rt in d2v_model.dv: sims.append(cos_sim(vec_recipe, d2v_model.dv[rt]))
+                        if sims: s_d2v = np.mean(sims)
+                s_method = 0.0 if w_method <= 0 else get_stat_score(clean_cand, current_method, ing_method_counts, total_method_counts, TOTAL_RECIPES)
+                s_cat = 0.0 if w_cat <= 0 else get_stat_score(clean_cand, current_cat, ing_cat_counts, total_cat_counts, TOTAL_RECIPES)
+                temp_candidates.append({"cand": clean_cand, "raw_w2v": s_w2v, "raw_d2v": s_d2v, "raw_method": s_method, "raw_cat": s_cat})
+            if not temp_candidates: continue
+            df_temp = pd.DataFrame(temp_candidates)
+            cols = ["raw_w2v", "raw_d2v", "raw_method", "raw_cat"]
+            for col in cols:
+                min_val = df_temp[col].min()
+                max_val = df_temp[col].max()
+                if max_val - min_val == 0: df_temp[col + "_norm"] = 0.5
+                else: df_temp[col + "_norm"] = (df_temp[col] - min_val) / (max_val - min_val)
+            for _, r in df_temp.iterrows():
+                weighted_sum = ((r["raw_w2v_norm"]*w_w2v) + (r["raw_d2v_norm"]*w_d2v) + (r["raw_method_norm"]*w_method) + (r["raw_cat_norm"]*w_cat)) / total_weight
+                new_total_score = path_score + weighted_sum
+                new_subs = path_subs + [r["cand"]]
+                new_ctx = current_ctx_ing + [r["cand"]]
+                next_beam.append((new_total_score, new_subs, new_ctx))
+        next_beam.sort(key=lambda x: x[0], reverse=True)
+        beam = next_beam[:beam_width]
+    final_results = []
+    for score, subs, _ in beam:
+        avg_score = score / len(targets) if targets else 0.0
+        cand_ranks_sum = 0
+        for sub_ing in subs: cand_ranks_sum += get_estimated_price_rank(sub_ing, price_map)
+        total_saving_score = target_ranks_sum - cand_ranks_sum
+        final_results.append((subs, avg_score, total_saving_score))
+    return final_results[:result_topn]
+
+# ==========================================
+# 5. 커스텀 입력 기반 대체 알고리즘 (수정됨)
+# ==========================================
+def substitute_single_custom(target_ing, context_ings_list, user_stopwords, w_w2v, w_d2v, excluded_ings=None, topn=10):
+    if target_ing not in w2v_model.wv: return pd.DataFrame()
+    total_weight = w_w2v + w_d2v
+    if total_weight == 0: total_weight = 1.0
+    vec_custom_context = None
+    if w_d2v > 0:
+        valid_context = [word for word in context_ings_list if word in d2v_model.wv]
+        if valid_context: vec_custom_context = d2v_model.infer_vector(valid_context)
+    target_rank = get_estimated_price_rank(target_ing, price_map)
+    candidates_raw = w2v_model.wv.most_similar(target_ing, topn=50)
+    temp_results = []
+    seen_candidates = set()
+
+    # [수정] 실시간 로드
+    global_stopwords_set = set(load_global_stopwords())
+    final_stopwords = set(user_stopwords) | global_stopwords_set
+    excluded_set = set(excluded_ings) if excluded_ings else set()
+
+    for cand, score_w2v in candidates_raw:
+        clean_cand = cand
+        if final_stopwords:
+            for stop in final_stopwords: clean_cand = clean_cand.replace(stop, "")
+        clean_cand = clean_cand.strip()
+
+        if not clean_cand: continue
+        if clean_cand in final_stopwords: continue
+        if clean_cand in excluded_set: continue
+
+        if clean_cand in context_ings_list: continue
+        if clean_cand == target_ing: continue
+        if clean_cand not in w2v_model.wv: continue
+        if clean_cand in seen_candidates: continue
+        seen_candidates.add(clean_cand)
+        real_score_w2v = w2v_model.wv.similarity(target_ing, clean_cand)
+        s_w2v = max(0.0, real_score_w2v)
+        if s_w2v < 0.35: continue
+        s_d2v = 0.0
+        if w_d2v > 0 and vec_custom_context is not None:
+            rid_list = recipes_by_ingredient.get(clean_cand, [])
+            if len(rid_list) > 20:
+                np.random.seed(42)
+                rid_list = np.random.choice(rid_list, 20, replace=False)
+            if rid_list is not None and len(rid_list) > 0:
+                sims = []
+                for r in rid_list:
+                    rt = f"recipe_{r}"
+                    if rt in d2v_model.dv: sims.append(cos_sim(vec_custom_context, d2v_model.dv[rt]))
+                if sims: s_d2v = np.mean(sims)
+        s_method, s_cat = 0.0, 0.0
+        cand_rank = get_estimated_price_rank(clean_cand, price_map)
+        saving_score = target_rank - cand_rank
+        temp_results.append({"대체재료": clean_cand, "raw_W2V": s_w2v, "raw_D2V": s_d2v, "raw_Method": s_method, "raw_Category": s_cat, "saving_score": saving_score})
+    if not temp_results: return pd.DataFrame()
+    df_res = pd.DataFrame(temp_results)
+    cols = ["raw_W2V", "raw_D2V"]
+    norm_cols = ["W2V", "D2V"]
+    for raw_col, norm_col in zip(cols, norm_cols):
+        min_val = df_res[raw_col].min()
+        max_val = df_res[raw_col].max()
+        if max_val - min_val == 0: df_res[norm_col] = 0.5
+        else: df_res[norm_col] = (df_res[raw_col] - min_val) / (max_val - min_val)
+    df_res["최종점수"] = ((df_res["W2V"]*w_w2v) + (df_res["D2V"]*w_d2v)) / total_weight
+    return df_res.sort_values("최종점수", ascending=False).head(topn).reset_index(drop=True)
+
+def substitute_multi_custom(targets, context_ings_list, user_stopwords, w_w2v, w_d2v, excluded_ings=None, beam_width=3, result_topn=3):
+    total_weight = w_w2v + w_d2v
+    if total_weight == 0: total_weight = 1.0
+    vec_custom_context = None
+    if w_d2v > 0:
+        valid_context = [word for word in context_ings_list if word in d2v_model.wv]
+        if valid_context: vec_custom_context = d2v_model.infer_vector(valid_context)
+    target_ranks_sum = 0
+    for t in targets: target_ranks_sum += get_estimated_price_rank(t, price_map)
+    
+    # [수정] 실시간 로드
+    global_stopwords_set = set(load_global_stopwords())
+    final_stopwords = set(user_stopwords) | global_stopwords_set
+    excluded_set = set(excluded_ings) if excluded_ings else set()
+
+    beam = [(0.0, [], context_ings_list)]
+    for target_ing in targets:
+        next_beam = []
+        if target_ing not in w2v_model.wv:
+            for score, subs, ctx in beam: next_beam.append((score, subs + [target_ing], ctx))
+            beam = next_beam
+            continue
+        for path_score, path_subs, path_ctx in beam:
+            current_ctx_ing = [x for x in path_ctx if x != target_ing]
+            candidates = w2v_model.wv.most_similar(target_ing, topn=30)
+            temp_candidates = []
+            seen_candidates = set()
+            for cand, _ in candidates:
+                clean_cand = cand
+                if final_stopwords:
+                    for stop in final_stopwords: clean_cand = clean_cand.replace(stop, "")
+                clean_cand = clean_cand.strip()
+
+                if not clean_cand: continue
+                if clean_cand in final_stopwords: continue
+                if clean_cand in excluded_set: continue
+
+                if clean_cand in current_ctx_ing or clean_cand in path_subs: continue
+                if clean_cand == target_ing: continue
+                if clean_cand not in w2v_model.wv: continue
+                if clean_cand in seen_candidates: continue
+                seen_candidates.add(clean_cand)
+                sim_orig = w2v_model.wv.similarity(target_ing, clean_cand)
+                sim_orig = max(0.0, sim_orig)
+                if sim_orig < 0.3: continue
+                harmony_scores = [w2v_model.wv.similarity(clean_cand, c) for c in current_ctx_ing if c in w2v_model.wv]
+                sim_harmony = np.mean(harmony_scores) if harmony_scores else 0.0
+                s_w2v = 0.5 * sim_orig + 0.5 * max(0.0, sim_harmony)
+                s_d2v = 0.0
+                if w_d2v > 0:
+                    valid_path_ctx = [word for word in current_ctx_ing if word in d2v_model.wv]
+                    if valid_path_ctx:
+                        vec_path_context = d2v_model.infer_vector(valid_path_ctx)
+                        rid_list = recipes_by_ingredient.get(clean_cand, [])
+                        if len(rid_list) > 10:
+                            np.random.seed(42)
+                            rid_list = np.random.choice(rid_list, 10, replace=False)
+                        if rid_list is not None and len(rid_list) > 0:
+                            sims = []
+                            for r in rid_list:
+                                rt = f"recipe_{r}"
+                                if rt in d2v_model.dv: sims.append(cos_sim(vec_path_context, d2v_model.dv[rt]))
+                            if sims: s_d2v = np.mean(sims)
+                s_method, s_cat = 0.0, 0.0
+                temp_candidates.append({"cand": clean_cand, "raw_w2v": s_w2v, "raw_d2v": s_d2v})
+            if not temp_candidates: continue
+            df_temp = pd.DataFrame(temp_candidates)
+            cols = ["raw_w2v", "raw_d2v"]
+            for col in cols:
+                min_val = df_temp[col].min()
+                max_val = df_temp[col].max()
+                if max_val - min_val == 0: df_temp[col + "_norm"] = 0.5
+                else: df_temp[col + "_norm"] = (df_temp[col] - min_val) / (max_val - min_val)
+            for _, r in df_temp.iterrows():
+                weighted_sum = ((r["raw_w2v_norm"]*w_w2v) + (r["raw_d2v_norm"]*w_d2v)) / total_weight
+                new_total_score = path_score + weighted_sum
+                new_subs = path_subs + [r["cand"]]
+                new_ctx = current_ctx_ing + [r["cand"]]
+                next_beam.append((new_total_score, new_subs, new_ctx))
+        next_beam.sort(key=lambda x: x[0], reverse=True)
+        beam = next_beam[:beam_width]
+    final_results = []
+    for score, subs, _ in beam:
+        avg_score = score / len(targets) if targets else 0.0
+        cand_ranks_sum = 0
+        for sub_ing in subs: cand_ranks_sum += get_estimated_price_rank(sub_ing, price_map)
+        total_saving_score = target_ranks_sum - cand_ranks_sum
+        final_results.append((subs, avg_score, total_saving_score))
+    return final_results[:result_topn]
+
+# ==========================================
+# 6. 재료 키워드 기반 레시피 검색 (기존과 동일)
+# ==========================================
+def find_recipes_by_ingredient_keyword(keyword, topn=5):
+    keyword = keyword.strip()
+    if not keyword: return []
+    matched_dishes = set()
+    for _, row in df.iterrows():
+        for ing in row['재료토큰']:
+            if keyword in ing:
+                matched_dishes.add(row['요리명'])
+                break 
+    return list(matched_dishes)[:topn]