changes to adapt to hugging face

app.py

@@ -1,7 +1,4 @@
 # app.py
-
-import os
-from dotenv import load_dotenv
 import gradio as gr
 from langdetect import detect
 from deep_translator import GoogleTranslator
@@ -11,8 +8,6 @@ from cluster_predictor import get_user_cluster
 from region_extractor import extract_region_from_query
 from rag_retriever import get_rag_recommendation
 
-# --- 초기 설정 ---
-load_dotenv()
 
 # 언어 코드 매핑 (deep_translator 호환)
 LANG_CODE_MAP = {
@@ -129,4 +124,4 @@ with gr.Blocks() as demo:
     msg.submit(respond, [msg, chatbot, state], [msg, chatbot, state])
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch(show_api=False, debug=True)

cluster_predictor.py

@@ -5,11 +5,13 @@ import pandas as pd
 from openai import OpenAI
 import os
 import json
-from dotenv import load_dotenv
-import random
+from huggingface_hub import hf_hub_download
+
+# Hugging Face dataset repo에서 prompt 파일 로드
+PROMPT_PATH = hf_hub_download("Syngyeon/seoulalpha-data", "prompt/custom_prompt_eng.txt")
+FEWSHOT_PATH = hf_hub_download("Syngyeon/seoulalpha-data", "prompt/custom_few_shot_learning_multi_language.txt")
 
 # --- 초기 설정 ---
-load_dotenv()
 client = OpenAI(api_key=os.getenv("API_KEY"))
 
 CLUSTER_PROFILES = {
@@ -43,12 +45,12 @@ def query_llm_for_variables(user_query, use_prompt=True, use_fewshot=True):
     prompt_parts = []
 
     if use_prompt:
-        with open("data/prompt/custom_prompt_eng.txt", "r", encoding="utf-8") as f:
+        with open("PROMPT_PATH", "r", encoding="utf-8") as f:
             custom_prompt = f.read()
             prompt_parts.append(custom_prompt)
 
     if use_fewshot:
-        with open("data/prompt/custom_few_shot_learning_multi_language.txt", "r", encoding="utf-8") as f:
+        with open("FEWSHOT_PATH", "r", encoding="utf-8") as f:
             few_shot_examples = f.read()
             prompt_parts.append(few_shot_examples)
         

llm_cluster_predictor.py

@@ -1,198 +0,0 @@
-import subprocess
-import sys
-import os
-import json
-from dotenv import load_dotenv
-import os
-
-load_dotenv()
-
-# 환경 변수 사용
-USER_KEY = os.getenv("API_KEY")
-
-# 설치가 필요한 라이브러리 없는 경우 자동 설치
-def install_required_packages(package, import_name=None):
-    try:
-        if import_name:
-            __import__(import_name)
-        else:
-            __import__(package)
-    except ImportError:
-        print(f"📦 {package} 설치 중...")
-        subprocess.check_call([sys.executable, "-m", "pip", "install", package])
-        print(f"✅ {package} 설치 완료!")
-
-required_packages = [
-    ("scikit-learn", "sklearn"),
-    ("tqdm", "tqdm"),
-    ("openai", "openai"),
-    ("pandas", "pandas"),
-    ("numpy", "numpy")
-]
-
-for pkg, imp in required_packages:
-    install_required_packages(pkg, imp)
-
-from sklearn.preprocessing import OneHotEncoder, StandardScaler, MinMaxScaler
-from sklearn.compose import ColumnTransformer
-from sklearn.pipeline import Pipeline
-from sklearn.cluster import KMeans
-from sklearn.metrics import silhouette_score
-from sklearn.decomposition import PCA
-from sklearn.impute import SimpleImputer
-from tqdm import tqdm
-from openai import OpenAI
-import pandas as pd
-import numpy as np
-
-# OpenAI API 키 설정
-#USER_KEY = ""
-client = OpenAI(api_key=USER_KEY)
-
-# 데이터 준비
-preprocessed_data = pd.read_csv('./관광데이터.csv', encoding='cp949')
-
-# 변수 구분
-categorical_cols = ['country', 'gender', 'age',
-                    'revisit_indicator', 'visit_local_indicator', 'planned_activity']
-
-numerical_cols = [
-    'stay_duration', 'accommodation_percent', 'food_percent', 'shopping_percent', 'food',
-    'landscape', 'heritage', 'language', 'safety', 'budget',
-    'accommodation', 'transport', 'navigation'
-]
-used_variables = categorical_cols + numerical_cols
-
-for col in categorical_cols:
-    preprocessed_data[col] = preprocessed_data[col].astype(str)
-preprocessed_data_clean = preprocessed_data.dropna(subset=used_variables).copy()
-
-# 전처리 파이프라인 정의
-# 수치형 파이프라인: 평균 대체 + 정규화
-numeric_pipeline = Pipeline([
-    ('imputer', SimpleImputer(strategy='mean')),
-    ('scaler', MinMaxScaler())
-])
-
-# 범주형 파이프라인: 최빈값 대체 + 원핫인코딩
-categorical_pipeline = Pipeline([
-    ('imputer', SimpleImputer(strategy='most_frequent')),  
-    ('encoder', OneHotEncoder(handle_unknown='ignore'))
-])
-
-preprocessor = ColumnTransformer(transformers=[
-    ('cat', categorical_pipeline, categorical_cols),
-    ('num', numeric_pipeline, numerical_cols)
-])
-
-# 학습: 전처리 + PCA + 클러스터링
-X_preprocessed = preprocessor.fit_transform(preprocessed_data_clean)
-pca = PCA(n_components=3)
-X_reduced = pca.fit_transform(X_preprocessed)
-
-kmeans = KMeans(n_clusters=7, random_state=42)
-preprocessed_data_clean['cluster'] = kmeans.fit_predict(X_reduced)
-
-print("explained_variance_ratio:", pca.explained_variance_ratio_.sum())
-print(f"Silhouette Score: {silhouette_score(X_reduced, preprocessed_data_clean['cluster']):.4f}")
-
-# LLM 질의 = 변수 매핑 함수
-def load_text_file(filepath):
-    try:
-        with open(filepath, "r", encoding="utf-8") as f:
-            return f.read()
-    except Exception as e:
-        print(f"[파일 로딩 실패] {filepath} - {e}")
-        return ""
-
-def query_llm_for_variables(user_query, use_prompt=True, use_fewshot=True):
-    prompt_parts = []
-
-    if use_prompt:
-        with open("custom_prompt.txt", "r", encoding="utf-8") as f:
-            custom_prompt = f.read()
-            prompt_parts.append(custom_prompt)
-
-    if use_fewshot:
-        with open("custom_few_shot_learning.txt", "r", encoding="utf-8") as f:
-            few_shot_examples = f.read()
-            prompt_parts.append(few_shot_examples)
-
-    full_prompt = "\n\n".join(prompt_parts)
-
-    messages = [
-        {"role": "system", "content": full_prompt},
-        {"role": "user", "content": user_query}
-    ]
-
-    try:
-        response = client.chat.completions.create(
-            model="gpt-3.5-turbo",
-            messages=messages
-        )
-        content = response.choices[0].message.content.strip()
-        return json.loads(content)
-    except Exception as e:
-        print("[파싱 실패]", e)
-        return {}
-
-
-def impute_with_user_subgroup(user_input_dict, df_base):
-    known_info = {k: v for k, v in user_input_dict.items() if v is not None}
-    filtered_df = df_base.copy()
-    for key, val in known_info.items():
-        if key in filtered_df.columns:
-            filtered_df = filtered_df[filtered_df[key].astype(str) == str(val)]
-    imputed = {}
-    for var in used_variables:
-        if user_input_dict.get(var) is not None:
-            imputed[var] = user_input_dict[var]
-        else:
-            if var in numerical_cols:
-                imputed[var] = filtered_df[var].mean() if not filtered_df.empty else df_base[var].mean()
-            elif var in categorical_cols:
-                mode_series = filtered_df[var].mode() if not filtered_df.empty else df_base[var].mode()
-                imputed[var] = mode_series.iloc[0] if not mode_series.empty else None
-    return imputed
-
-# 질의 = 예측 함수
-def predict_cluster_from_query(user_query):
-    variable_dict = query_llm_for_variables(user_query, use_prompt=True, use_fewshot=True)
-    
-    # null이 아닌 값만 필터링하여 출력
-    filtered_dict = {k: v for k, v in variable_dict.items() if v is not None}
-    print("⮕ LLM 추출 결과:", filtered_dict)
-
-    # 결측 보완
-    completed_input = impute_with_user_subgroup(variable_dict, preprocessed_data_clean)
-    df = pd.DataFrame([completed_input])
-
-    for col in categorical_cols:
-        df[col] = df[col].astype(str)
-    for col in numerical_cols:
-        df[col] = pd.to_numeric(df[col], errors='coerce')
-
-    try:
-        X_processed = preprocessor.transform(df)
-        X_pca = pca.transform(X_processed)
-        cluster_label = kmeans.predict(X_pca)[0]
-        return cluster_label
-    except Exception as e:
-        print("[예측 실패]", e)
-        return None
-    
-# main block
-if __name__ == "__main__":
-    test_inputs = [
-        "나는 50대 남성이고, 자연 풍경을 좋아해서 제주도에 4일 여행했어요",
-        "저는 20대 여성이며 쇼핑을 좋아해요. 서울에서 3일간 머물렀어요",
-        "나는 30대 남자고 한국 전통문화 체험이 좋아서 전주에 갔어요. 총 5일 있었어요",
-        "저는 미국에서 왔고, 처음 방문했어요. 한국 음식에 관심이 많아 6일간 머물렀어요",
-        "저는 일본 여성이고, 두 번째 방문입니다. 자연 풍경과 유적지를 보기 위해 강원도에 7일 머물렀어요"
-    ]
-
-    for i, user_input in enumerate(test_inputs, 1):
-        cluster = predict_cluster_from_query(user_input)
-        print(f"# 실행 예시 {i}")
-        print(f"입력 문장: {user_input}")
-        print(f"예측된 클러스터: {cluster}\n")

rag_retriever.py

@@ -6,22 +6,13 @@ import faiss
 import numpy as np
 from sentence_transformers import SentenceTransformer
 from openai import OpenAI
-from dotenv import load_dotenv
+from huggingface_hub import hf_hub_download
 
 # --- 설정 ---
-# .env 파일 로드
-load_dotenv()
-
-# os.environ['HF_HOME'] = 'D:/huggingface_cache'
-
-# 모델 및 파일 경로 정의
 MODEL_NAME = 'jhgan/ko-sbert-nli'
-#LLM_MODEL_NAME = 'gpt-4o-mini'
 LLM_MODEL_NAME = 'gpt-3.5-turbo'
-OUTPUT_DIR = 'data/faiss/faiss_merged_output'
-INDEX_FILE = f'{OUTPUT_DIR}/merged.index'
-METADATA_FILE = f'{OUTPUT_DIR}/merged_metadata.jsonl'
-TOP_K = 10  # 검색할 결과의 수
+DATA_REPO = "Syngyeon/seoulalpha-data" 
+TOP_K = 10
 
 # OpenAI 클라이언트 초기화
 client = OpenAI(api_key=os.getenv("API_KEY"))
@@ -30,14 +21,24 @@ client = OpenAI(api_key=os.getenv("API_KEY"))
 def _load_resources():
     """모듈 로딩 시 검색에 필요한 리소스를 미리 불러옵니다."""
     try:
-        print("1. RAG 리소스를 로딩합니다...")
+        print("1. Hugging Face Hub에서 RAG 리소스를 다운로드합니다...")
+
+        # HF repo에서 파일 다운로드
+        index_path = hf_hub_download(repo_id=DATA_REPO, filename="data/faiss/faiss_merged_output/merged.index")
+        metadata_path = hf_hub_download(repo_id=DATA_REPO, filename="data/faiss/faiss_merged_output/merged_metadata.jsonl")
+        # 임베딩 모델 로드
         model = SentenceTransformer(MODEL_NAME)
-        index = faiss.read_index(INDEX_FILE)
+
+        # FAISS index 로드
+        index = faiss.read_index(index_path)
+
+        # 메타데이터 로드
         metadata_map = {}
-        with open(METADATA_FILE, 'r', encoding='utf-8') as f:
+        with open(metadata_path, 'r', encoding='utf-8') as f:
             for line in f:
                 meta = json.loads(line)
                 metadata_map[meta['vector_id']] = meta
+
         print("RAG 리소스 로딩 완료!")
         return model, index, metadata_map
     except Exception as e:
@@ -52,7 +53,7 @@ def _retrieve_places(query, k):
     """내부 함수: 쿼리를 기반으로 유사한 장소를 검색합니다."""
     query_vector = embedding_model.encode([query])
     distances, ids = faiss_index.search(query_vector.astype('float32'), k)
-    
+
     results = []
     for vector_id in ids[0]:
         if vector_id in meta_map:
@@ -60,14 +61,13 @@ def _retrieve_places(query, k):
     return results
 
 
-
 def _generate_answer_with_llm(query, retrieved_places):
     """내부 함수: 검색된 정보를 바탕으로 LLM 답변을 생성합니다."""
     context = ""
-    for i, place in enumerate(retrieved_places[:5]): # 상위 5개 정보만 사용
+    for i, place in enumerate(retrieved_places[:5]):  # 상위 5개 정보만 사용
         context += f"--- 장소 정보 {i+1} ---\n"
         context += f"이름: {place.get('name', '정보 없음')}\n"
-        context += f"주소: {place.get('address', '정보 없음')}\n"  # <--- 1. '주소' 정보 추가
+        context += f"주소: {place.get('address', '정보 없음')}\n"
         context += f"AI 요약: {place.get('ai_summary', '정보 없음')}\n"
         processed_sentences = place.get('processed_sentences', [])
         context += "주요 특징 및 후기:\n"
@@ -76,7 +76,6 @@ def _generate_answer_with_llm(query, retrieved_places):
         context += "\n"
 
     system_prompt = "당신은 사용자의 질문에 가장 적합한 장소를 추천해주는 유용한 어시스턴트입니다."
-    # <--- 2. 지시사항 수정
     user_prompt = f"""
     아래 '장소 정보'만을 바탕으로 사용자의 질문에 대한 답변을 생성해 주세요.
 
@@ -106,27 +105,22 @@ def _generate_answer_with_llm(query, retrieved_places):
         return f"LLM 답변 생성 중 오류가 발생했습니다: {e}"
 
 
-
-
-
 # --- 대표 실행 함수 ---
-# search_query 외에 region_keywords를 인자로 받도록 변경
 def get_rag_recommendation(search_query, region_keywords):
     """
     검색 쿼리와 지역 키워드를 받아 RAG 시스템을 통해 최종 추천 답변을 반환합니다.
     """
     if not all([embedding_model, faiss_index, meta_map]):
         return "RAG 시스템이 준비되지 않아 추천을 생성할 수 없습니다."
-        
+
     # 1. 장소 검색
     print("\n[RAG] 의미적으로 유사한 장소를 검색합니다...")
     top_places = _retrieve_places(search_query, k=100)
-    
+
     if not top_places:
         return "관련된 장소를 찾지 못했습니다."
 
-    # 2. 지역 필터링 (전달받은 키워드 사용)
-    # region_keywords 리스트가 비어있지 않은 경우에만 필터링 수행
+    # 2. 지역 필터링
     if region_keywords:
         print(f"[RAG] 주소 필터링 (키워드: {region_keywords})...")
         filtered_places = []
@@ -134,20 +128,18 @@ def get_rag_recommendation(search_query, region_keywords):
             address = place.get('address', '')
             if any(keyword in address for keyword in region_keywords):
                 filtered_places.append(place)
-
-            if len(filtered_places) >= 10: break    
-        
+            if len(filtered_places) >= 10:
+                break
         print(f"[RAG] 필터링 후 남은 장소: {[p.get('name') for p in filtered_places]}")
     else:
-        # 지역 키워드가 없으면 필터링 없이 그대로 사용
         print("[RAG] 지역 키워드가 없어 필터링을 건너뜁니다.")
         filtered_places = top_places
-    
+
     if not filtered_places:
         return "요청하신 지역에 맞는 장소를 찾지 못했습니다."
 
     # 3. LLM으로 답변 생성
     print("[RAG] 필터링된 정보를 바탕으로 최종 답변을 생성합니다...")
     final_answer = _generate_answer_with_llm(search_query, filtered_places)
-    
-    return final_answer
+
+    return final_answer

region_extractor.py

@@ -1,66 +1,47 @@
-from dotenv import load_dotenv
-import random
-from openai import OpenAI
 import os
 import json
+import faiss
+import numpy as np
+from sentence_transformers import SentenceTransformer
+from huggingface_hub import hf_hub_download
 
-# --- 초기 설정 ---
-load_dotenv()
-client = OpenAI(api_key=os.getenv("API_KEY"))
+DATA_REPO = "Syngyeon/seoulalpha-data"
+MODEL_NAME = "jhgan/ko-sbert-nli"
 
+# 로드
+def _load_region_index():
+    try:
+        index_path = hf_hub_download(repo_id=DATA_REPO, filename="data/faiss/region_db/faiss_region_semantic.index")
+        metadata_path = hf_hub_download(repo_id=DATA_REPO, filename="data/faiss/region_db/metadata_region_semantic.jsonl")
 
-def extract_region_from_query(user_query):
-    """
-    사용자 질문에서 LLM을 사용해 지역명 키워드 리스트를 추출합니다.
-    """
-    print("[LLM] 사용자 쿼리에서 지역명 키워드를 추출합니다...")
-    
-    # LLM에게 역할을 부여하고, 예시(Few-shot)를 통해 원하는 결과 형식을 명확히 알려줍니다.
-    system_prompt = """
-    당신은 사용자의 여행 관련 질문에서 '대한민국 행정구역' 키워드를 추출하는 AI 어시스턴트입니다.
-    사용자의 질문을 분석하여, 주소 필터링에 사용할 수 있는 키워드 목록을 JSON 형식으로 반환해 주세요.
-    결과는 반드시 {"regions": ["키워드1", "키워드2", ...]} 형태여야 합니다.
-    
-    - "전라도"는 "전북", "전남", "광주"로 해석합니다.
-    - "경상도"는 "경북", "경남", "부산", "대구", "울산"으로 해석합니다.
-    - "충청도"는 "충북", "충남", "대전", "세종"으로 해석합니다.
-    - "서울 근교"는 "경기", "인천"으로 해석합니다.
-    - 언급된 지역이 없으면 빈 리스트 []를 반환합니다.
-    
-    # 예시1
-    사용자: "전라도 쪽으로 맛집 투어 가고 싶어"
-    AI: {"regions": ["전북", "전남", "광주"]}
+        index = faiss.read_index(index_path)
+        model = SentenceTransformer(MODEL_NAME)
 
-    # 예시2
-    사용자: "강원도나 경주 쪽 바다 보고 싶다"
-    AI: {"regions": ["강원", "경주"]}
-    
-    # 예시3
-    사용자: "그냥 조용한 곳이면 돼"
-    AI: {"regions": []}
-    """
-    
-    messages = [
-        {"role": "system", "content": system_prompt},
-        {"role": "user", "content": user_query}
-    ]
-    
-    try:
-        response = client.chat.completions.create(
-            model="gpt-3.5-turbo",
-            messages=messages,
-            response_format={"type": "json_object"}
-        )
-        result = json.loads(response.choices[0].message.content)
-        
-        # 'regions' 키가 있고, 그 값이 리스트인지 확인
-        if 'regions' in result and isinstance(result['regions'], list):
-            #print(f"[LLM] 추출된 지역 키워드: {result['regions']}")
-            return result['regions']
-        else:
-            #print("[LLM] 'regions' 키를 찾지 못했거나 형식이 리스트가 아닙니다.")
-            return []
-            
+        metadata_map = {}
+        with open(metadata_path, "r", encoding="utf-8") as f:
+            for line in f:
+                meta = json.loads(line)
+                metadata_map[meta["vector_id"]] = meta
+
+        print("[RegionDB] 로딩 완료")
+        return model, index, metadata_map
     except Exception as e:
-        #print(f"[LLM] 지역명 추출 중 오류 발생: {e}")
+        print("[RegionDB] 로딩 실패:", e)
+        return None, None, None
+
+region_model, region_index, region_meta = _load_region_index()
+
+
+def extract_region_semantic(user_query, top_k=5):
+    """FAISS 기반 지역 후보 추출"""
+    if not all([region_model, region_index, region_meta]):
         return []
+
+    query_vec = region_model.encode([user_query]).astype("float32")
+    distances, ids = region_index.search(query_vec, top_k)
+
+    results = []
+    for i, vid in enumerate(ids[0]):
+        if vid in region_meta:
+            results.append(region_meta[vid]["region_name"])
+    return results