import json
from transformers import AutoTokenizer, AutoModelForSeq2SeqLM

class LLMQueryExpander:
    def __init__(self, model_name="google/flan-t5-base"):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
    
    def generate_expansions(self, query, num_expansions=4, prompt_type="CoT"):
        # prompt 설계: 사용자의 쿼리와 원하는 확장 방식에 따른 prompt 구성
        if prompt_type == "CoT":
            prompt = f"다음 쿼리에 대해 관련 키워드들을 단계별로 생성해줘:\nQuery: '{query}'\nStep-by-step 키워드 리스트:"
        else:
            prompt = f"Query: '{query}'\n관련된 키워드 리스트를 생성해줘:"
        
        inputs = self.tokenizer(prompt, return_tensors="pt")
        outputs = self.model.generate(
            **inputs,
            max_length=128,
            num_return_sequences=1,
            do_sample=True,
            top_p=0.9,
            temperature=0.7
        )
        response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
        # 간단하게 줄바꿈이나 쉼표 기준 분할
        keywords = [kw.strip() for kw in response.split('\n') if kw.strip()]
        # 원본 쿼리 포함
        if query not in keywords:
            keywords.append(query)
        return keywords

# 사용 예제
if __name__ == "__main__":
    query = "open source nlp frameworks"
    expander = LLMQueryExpander()
    expanded_queries = expander.generate_expansions(query, prompt_type="CoT")
    print("Expanded Queries:", expanded_queries)

import difflib

# 예제 사전: 브랜드, 카테고리, 계절 키워드
domain_dict = {
    "브랜드": ["Nike", "Adidas", "Puma"],
    "카테고리": ["운동화", "티셔츠", "백"],
    "계절": {
        "봄": ["라이트 재킷", "플로럴 패턴", "맨투맨"],
        "여름": ["반팔", "샌들", "쿨링 아이템"],
        "가을": ["코트", "부츠", "니트"],
        "겨울": ["패딩", "스웨터", "장갑"]
    }
}

def correct_typo(word, dictionary):
    # dictionary는 단어 리스트 형태
    match = difflib.get_close_matches(word, dictionary, n=1, cutoff=0.8)
    return match[0] if match else word

def expand_with_domain(query, user_profile=None, season=None):
    expanded_terms = set([query])
    # 오타 보정: 예를 들어 사용자가 "adids"라고 썼다면 "Adidas"로 보정
    for category, items in domain_dict.items():
        if category == "계절":
            continue
        for item in items:
            corrected = correct_typo(query, items)
            if corrected != query:
                expanded_terms.add(corrected)
    
    # 유저 프로파일 기반 확장 (간단한 예: 선호 카테고리 추가)
    if user_profile and "선호_카테고리" in user_profile:
        expanded_terms.update(user_profile["선호_카테고리"])
    
    # 계절 기반 확장
    if season and season in domain_dict["계절"]:
        expanded_terms.update(domain_dict["계절"][season])
    
    return list(expanded_terms)

# 사용 예제
if __name__ == "__main__":
    query = "adids"
    user_profile = {"선호_카테고리": ["운동화"]}
    season = "여름"
    domain_expansions = expand_with_domain(query, user_profile, season)
    print("Domain-based Expansions:", domain_expansions)

def integrated_query_expansion(query, user_profile=None, season=None):
    # Step 1: 전처리 및 오타 보정
    preprocessed_query = correct_typo(query, domain_dict["브랜드"] + domain_dict["카테고리"])
    
    # Step 2: LLM 기반 확장
    llm_expander = LLMQueryExpander()
    llm_keywords = llm_expander.generate_expansions(preprocessed_query, prompt_type="CoT")
    
    # Step 3: 사전 기반 확장 (도메인/유저/계절)
    domain_keywords = expand_with_domain(preprocessed_query, user_profile, season)
    
    # Step 4: 통합 및 정제
    all_keywords = list(set(llm_keywords + domain_keywords))
    return all_keywords

# 파이프라인 실행 예제
if __name__ == "__main__":
    original_query = "adids running shoes"
    user_profile = {"선호_카테고리": ["운동화"]}
    season = "여름"
    final_expansions = integrated_query_expansion(original_query, user_profile, season)
    print("최종 확장 쿼리:", final_expansions)

import difflib

# 패션 도메인 사전 예시
fashion_dict = {
    "브랜드": ["Adidas", "Nike", "Puma", "Reebok"],
    "카테고리": ["운동화", "티셔츠", "백", "바지"],
}

def correct_typo(query, domain_list):
    words = query.split()
    corrected = []
    for word in words:
        match = difflib.get_close_matches(word, domain_list, n=1, cutoff=0.8)
        corrected.append(match[0] if match else word)
    return " ".join(corrected)

# 사용 예
query = "adids running shoes"
domain_terms = fashion_dict["브랜드"] + fashion_dict["카테고리"]
clean_query = correct_typo(query, domain_terms)
print("Corrected Query:", clean_query)  # 예: "Adidas running shoes"

from transformers import AutoTokenizer, AutoModelForSeq2SeqLM

class FashionLLMQueryExpander:
    def __init__(self, model_name="google/flan-t5-base"):
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
    
    def generate_expansions(self, query, num_expansions=4):
        prompt = (
            f"패션 도메인에서 사용자의 쿼리 '{query}'에 대해 관련된 대체 검색어를 단계별로 생성해줘. "
            "예를 들어, '여름 운동화'라면 '쿨링 운동화', '라이트 소재 운동화' 등을 생성할 수 있어."
        )
        inputs = self.tokenizer(prompt, return_tensors="pt")
        outputs = self.model.generate(
            **inputs,
            max_length=128,
            num_return_sequences=1,
            do_sample=True,
            top_p=0.9,
            temperature=0.7
        )
        response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
        keywords = [kw.strip() for kw in response.split('\n') if kw.strip()]
        if query not in keywords:
            keywords.append(query)
        return keywords

# 사용 예
if __name__ == "__main__":
    expander = FashionLLMQueryExpander()
    expansions = expander.generate_expansions("여름 운동화")
    print("LLM 확장 쿼리:", expansions)

def domain_mapping_expansion(query, user_profile=None, season=None):
    domain_expansions = set([query])
    
    # 패션 도메인 사전 (예시)
    domain_dict = {
        "브랜드": ["Adidas", "Nike", "Puma", "Reebok"],
        "카테고리": ["운동화", "티셔츠", "백", "바지"],
        "계절": {
            "봄": ["라이트 재킷", "플로럴 패턴"],
            "여름": ["쿨링", "라이트 소재", "통기성"],
            "가을": ["코트", "부츠", "니트"],
            "겨울": ["패딩", "스웨터", "장갑"]
        },
        "성별": {
            "남성": ["맨즈", "남성 전용"],
            "여성": ["우먼", "여성 전용"]
        }
    }
    
    # 브랜드, 카테고리 매핑: 단순 치환 또는 유사어 보정 적용
    for key in ["브랜드", "카테고리"]:
        for term in domain_dict[key]:
            if term.lower() in query.lower():
                domain_expansions.add(term)
    
    # 계절 및 사용자 프로파일 반영
    if season in domain_dict["계절"]:
        for term in domain_dict["계절"][season]:
            domain_expansions.add(term)
    if user_profile and "선호_카테고리" in user_profile:
        for term in user_profile["선호_카테고리"]:
            domain_expansions.add(term)
    
    return list(domain_expansions)

# 사용 예
if __name__ == "__main__":
    user_profile = {"선호_카테고리": ["운동화"]}
    mapped_terms = domain_mapping_expansion("여름 운동화", user_profile, season="여름")
    print("도메인 기반 확장:", mapped_terms)

from elasticsearch import Elasticsearch

def integrated_search(query, user_profile=None, season=None):
    # 1. 전처리
    clean_query = correct_typo(query, fashion_dict["브랜드"] + fashion_dict["카테고리"])
    
    # 2. LLM 기반 확장
    llm_expander = FashionLLMQueryExpander()
    llm_keywords = llm_expander.generate_expansions(clean_query)
    
    # 3. 도메인 기반 확장
    domain_keywords = domain_mapping_expansion(clean_query, user_profile, season)
    
    # 4. 통합 키워드 생성
    all_keywords = list(set(llm_keywords + domain_keywords))
    
    # 5. Elasticsearch 쿼리 구성 (e.g., bool multi_match)
    es_query = {
        "query": {
            "bool": {
                "should": [
                    {
                        "multi_match": {
                            "query": " ".join(all_keywords),
                            "fields": [
                                "title^3", 
                                "description", 
                                "brand^2", 
                                "category",
                                "season",
                                "gender"
                            ],
                            "type": "best_fields"
                        }
                    }
                ]
            }
        }
    }
    
    # 6. ES 검색 실행
    es = Elasticsearch("http://localhost:9200")
    results = es.search(index="fashion_products", body=es_query)
    return results

# 사용 예
if __name__ == "__main__":
    user_profile = {"선호_카테고리": ["운동화"]}
    search_results = integrated_search("adids running shoes", user_profile, season="여름")
    print("최종 검색 결과:", search_results)

# 간단한 쿼리 확장 예시
original_query = "노트북 추천"
expanded_query = "노트북 추천 구매 랩탑 컴퓨터 맥북 윈도우 최신"

from rank_bm25 import BM25Okapi
import numpy as np
from sklearn.feature_extraction.text import CountVectorizer

def pseudo_relevance_feedback(query, documents, top_k=3, expansion_terms=5):
    # 초기 검색 수행
    tokenized_docs = [doc.split() for doc in documents]
    bm25 = BM25Okapi(tokenized_docs)
    initial_scores = bm25.get_scores(query.split())
    top_docs_indices = np.argsort(initial_scores)[-top_k:]
    
    # 상위 문서에서 용어 추출
    vectorizer = CountVectorizer()
    term_doc_matrix = vectorizer.fit_transform([documents[i] for i in top_docs_indices])
    terms = vectorizer.get_feature_names_out()
    
    # 용어 가중치 계산 (TF-IDF 기반)
    term_weights = np.sum(term_doc_matrix.toarray(), axis=0)
    
    # 기존 쿼리 용어 제외
    query_terms = set(query.split())
    expansion_terms_indices = []
    for i, term in enumerate(terms):
        if term not in query_terms:
            expansion_terms_indices.append((i, term_weights[i]))
    
    # 상위 n개 용어 선택
    expansion_terms_indices.sort(key=lambda x: x[1], reverse=True)
    expanded_terms = [terms[i] for i, _ in expansion_terms_indices[:expansion_terms]]
    
    # 확장된 쿼리 생성
    expanded_query = query + " " + " ".join(expanded_terms)
    return expanded_query

def bo1_term_weighting(term_freq_in_top_docs, term_freq_in_collection, total_terms_in_collection, top_k):
    pt = term_freq_in_collection / total_terms_in_collection
    ft = term_freq_in_top_docs / top_k
    
    # Bo1 weighting
    weight = ft * np.log2((1 + pt) / pt) + np.log2(1 + pt)
    return weight

def kl_term_weighting(term_freq_in_top_docs, term_freq_in_collection, total_terms_in_top_docs, total_terms_in_collection):
    pt = term_freq_in_top_docs / total_terms_in_top_docs
    qt = term_freq_in_collection / total_terms_in_collection
    
    # KL weighting
    weight = pt * np.log2(pt / qt)
    return weight

from nltk.corpus import wordnet

def expand_query_with_wordnet(query):
    expanded_terms = []
    for word in query.split():
        # 동의어 찾기
        synsets = wordnet.synsets(word, lang='eng')
        for synset in synsets[:2]:  # 상위 2개 의미만 고려
            for lemma in synset.lemmas():
                expanded_terms.append(lemma.name().replace('_', ' '))
    
    # 중복 제거 및 원래 쿼리와 결합
    expanded_terms = list(set(expanded_terms))
    expanded_query = query + " " + " ".join(expanded_terms)
    return expanded_query

import requests

def expand_query_with_conceptnet(query, lang='ko'):
    expanded_terms = []
    for word in query.split():
        # ConceptNet API 호출
        url = f"http://api.conceptnet.io/c/{lang}/{word}"
        response = requests.get(url).json()
        
        # 관련 개념 추출
        for edge in response.get('edges', [])[:10]:
            if edge['rel']['label'] in ['RelatedTo', 'Synonym', 'IsA']:
                target = edge['end']['label']
                if target != word:
                    expanded_terms.append(target)
    
    # 중복 제거 및 원래 쿼리와 결합
    expanded_terms = list(set(expanded_terms))
    expanded_query = query + " " + " ".join(expanded_terms)
    return expanded_query

class DomainSpecificDictionary:
    def __init__(self):
        # 도메인 특화 사전 예시 (실제로는 더 큰 규모로 구축)
        self.fashion_dict = {
            '티셔츠': ['반팔티', '티', '상의', '반소매'],
            '청바지': ['데님', '진', '팬츠', '하의'],
            '원피스': ['드레스', '롱드레스', '여성복'],
        }
        
        self.tech_dict = {
            '노트북': ['랩탑', '컴퓨터', 'PC', '맥북'],
            '스마트폰': ['핸드폰', '휴대폰', '모바일', '아이폰', '갤럭시'],
            '이어폰': ['헤드폰', '버즈', '에어팟', '블루투스 이어폰'],
        }
        
        self.brand_dict = {
            '나이키': ['nike', '스우시', '나이키'],
            '애플': ['apple', '맥', '아이폰', '아이패드'],
            '삼성': ['samsung', 'galaxy', '갤럭시'],
        }
    
    def expand_query(self, query, domains=['fashion', 'tech', 'brand']):
        expanded_terms = []
        query_terms = query.split()
        
        for term in query_terms:
            # 패션 도메인 확인
            if 'fashion' in domains and term in self.fashion_dict:
                expanded_terms.extend(self.fashion_dict[term])
            
            # 기술 도메인 확인
            if 'tech' in domains and term in self.tech_dict:
                expanded_terms.extend(self.tech_dict[term])
            
            # 브랜드 도메인 확인
            if 'brand' in domains and term in self.brand_dict:
                expanded_terms.extend(self.brand_dict[term])
        
        # 중복 제거 및 원래 쿼리와 결합
        expanded_terms = list(set(expanded_terms) - set(query_terms))
        expanded_query = query + " " + " ".join(expanded_terms)
        return expanded_query

import openai

def expand_query_zero_shot(query, model="gpt-3.5-turbo", num_expansions=5):
    prompt = f"""
    당신은 검색 시스템의 일부로, 사용자 쿼리를 유사한 의미를 가진 여러 쿼리로 확장
    쿼리: "{query}"
    이 쿼리와 유사한 의미를 가진 {num_expansions}개의 대체 쿼리를 생성해주세요.
    결과는 JSON 형식의 문자열 배열로만 반환해주세요.
    """
    
    response = openai.ChatCompletion.create(
        model=model,
        messages=[{"role": "system", "content": "You are a helpful assistant that expands search queries."},
                  {"role": "user", "content": prompt}],
        temperature=0.7
    )
    
    # JSON 파싱
    import json
    try:
        expanded_queries = json.loads(response.choices[0].message.content)
        # 원래 쿼리 추가
        expanded_queries.append(query)
        return expanded_queries
    except:
        print("JSON 파싱 오류, 텍스트 응답:", response.choices[0].message.content)
        return [query]  # 오류시 원래 쿼리만 반환

def expand_query_few_shot(query, model="gpt-3.5-turbo", num_expansions=5):
    prompt = f"""
    당신은 검색 시스템의 일부로, 사용자 쿼리를 유사한 의미를 가진 여러 쿼리로 확장
    
    예시:
    원래 쿼리: "스마트폰 추천"
    확장 쿼리: ["최신 핸드폰 추천", "갤럭시 아이폰 비교", "2025년 휴대폰 추천", "고성능 모바일 기기", "가성비 스마트폰"]
    
    원래 쿼리: "여름 바캉스 코디"
    확장 쿼리: ["여름 휴가 패션", "바캉스 룩북", "해변 패션 코디", "여름 여행 의류", "피서지 복장 추천"]
    
    원래 쿼리: "제주도 맛집"
    확장 쿼리: ["제주 유명 식당", "제주도 현지인 맛집", "제주 해산물 맛집", "제주도 카페 추천", "제주 맛집 투어"]
    
    이제 다음 쿼리를 확장해주세요:
    원래 쿼리: "{query}"
    확장 쿼리: 
    """
    
    response = openai.ChatCompletion.create(
        model=model,
        messages=[{"role": "system", "content": "You are a helpful assistant that expands search queries."},
                  {"role": "user", "content": prompt}],
        temperature=0.7
    )
    
    # 응답 파싱
    import json
    import re
    
    result = response.choices[0].message.content
    # 정규식으로 대괄호 안의 내용 추출
    match = re.search(r'$$(.*)$$', result, re.DOTALL)
    if match:
        try:
            expanded_queries = json.loads(f"[{match.group(1)}]")
            expanded_queries.append(query)  # 원래 쿼리 추가
            return expanded_queries
        except:
            print("JSON 파싱 오류, 텍스트 응답:", result)
    
    return [query]  # 오류시 원래 쿼리만 반환

def expand_query_cot(query, model="gpt-3.5-turbo", num_expansions=5):
    prompt = f"""
    당신은 검색 시스템의 일부로, 사용자 쿼리를 분석하고 확장하는 역할을 
    
    다음 단계를 따라 쿼리를 확장해주세요:
    1. 쿼리의 핵심 개념과 의도 파악하기
    2. 핵심 개념과 관련된 동의어, 관련어, 상위어 생각하기
    3. 사용자의 잠재적 의도와 관련된 다양한 측면 고려하기
    4. 원래 쿼리와 유사하지만 다양한 표현을 사용한 확장 쿼리 생성하기
    
    쿼리: "{query}"
    
    단계별로 분석한 후, 최종적으로 {num_expansions}개의 확장 쿼리를 생성해주세요.
    결과는 JSON 형식의 문자열 배열로 반환해주세요.
    """
    
    response = openai.ChatCompletion.create(
        model=model,
        messages=[{"role": "system", "content": "You are a helpful assistant that expands search queries."},
                  {"role": "user", "content": prompt}],
        temperature=0.7
    )
    
    # JSON 파싱을 시도
    import json
    import re
    
    result = response.choices[0].message.content
    # 마지막 JSON 배열 추출 시도
    matches = re.findall(r'$$(.*?)$$', result, re.DOTALL)
    if matches:
        try:
            expanded_queries = json.loads(f"[{matches[-1]}]")  # 마지막 배열 사용
            expanded_queries.append(query)  # 원래 쿼리 추가
            return expanded_queries
        except:
            pass
    
    # 텍스트에서 쿼리 추출 시도
    expanded_queries = [query]  # 원래 쿼리 포함
    lines = result.split('\n')
    for line in lines:
        if '"' in line and ':' not in line and '{' not in line and '}' not in line:
            # 따옴표 안의 내용 추출
            match = re.search(r'"([^"]*)"', line)
            if match and match.group(1) != query and len(match.group(1)) > 0:
                expanded_queries.append(match.group(1))
    
    # 중복 제거
    expanded_queries = list(set(expanded_queries))
    if len(expanded_queries) > 1:  # 원래 쿼리 외에 추가된 것이 있으면
        return expanded_queries
    
    # 모든 방법이 실패하면 원래 쿼리만 반환
    return [query]

def expand_query_prf_llm(query, documents, model="gpt-3.5-turbo", top_k=3, num_expansions=5):
    # 초기 검색으로 관련 문서 찾기
    tokenized_docs = [doc.split() for doc in documents]
    bm25 = BM25Okapi(tokenized_docs)
    initial_scores = bm25.get_scores(query.split())
    top_docs_indices = np.argsort(initial_scores)[-top_k:]
    prf_docs = [documents[i] for i in top_docs_indices]
    
    # PRF 문서를 컨텍스트로 LLM에 제공
    prompt = f"""
    당신은 검색 시스템의 일부로, 사용자 쿼리를 확장하는 역할을 
    
    원래 쿼리: "{query}"
    
    다음은 이 쿼리와 관련된 상위 검색 결과입니다.
    {prf_docs}
    
    이 정보를 바탕으로, 원래 쿼리와 유사하지만 다양한 의미를 포함하는 {num_expansions}개의 확장 쿼리를 생성해주세요.
    결과는 JSON 형식의 문자열 배열로 반환해주세요.
    """
    
    response = openai.ChatCompletion.create(
        model=model,
        messages=[{"role": "system", "content": "You are a helpful assistant that expands search queries."},
                  {"role": "user", "content": prompt}],
        temperature=0.7
    )
    
    # JSON 파싱
    import json
    try:
        expanded_queries = json.loads(response.choices[0].message.content)
        expanded_queries.append(query)  # 원래 쿼리 추가
        return expanded_queries
    except:
        # 파싱 실패시 원래 쿼리만 반환
        return [query]

from datetime import datetime

class SeasonalQueryExpander:
    def __init__(self):
        # 계절별 확장 사전
        self.seasonal_dict = {
            'spring': {
                '옷': ['봄옷', '봄코디', '봄패션', '가디건', '트렌치코트'],
                '여행': ['봄여행', '꽃구경', '벚꽃', '봄나들이', '피크닉'],
                '음식': ['봄나물', '딸기', '냉이', '취나물', '봄특선']
            },
            'summer': {
                '옷': ['여름옷', '반팔', '린넨', '민소매', '수영복', '바캉스룩'],
                '여행': ['해수욕장', '워터파크', '바다', '계곡', '섬여행'],
                '음식': ['빙수', '냉면', '팥빙수', '아이스크림', '시원한']
            },
            'autumn': {
                '옷': ['가을옷', '가을코디', '니트', '트렌치코트', '자켓'],
                '여행': ['단풍구경', '가을여행', '산책', '하이킹', '등산'],
                '음식': ['고구마', '밤', '사과', '버섯', '전골']
            },
            'winter': {
                '옷': ['겨울옷', '패딩', '코트', '목도리', '장갑', '부츠'],
                '여행': ['스키', '겨울여행', '눈구경', '온천', '실내'],
                '음식': ['겨울간식', '핫초코', '찜', '탕', '국물요리']
            }
        }
    
    def get_current_season(self):
        # 현재 월을 기준으로 계절 반환
        month = datetime.now().month
        if 3 <= month <= 5:
            return 'spring'
        elif 6 <= month <= 8:
            return 'summer'
        elif 9 <= month <= 11:
            return 'autumn'
        else:
            return 'winter'
    
    def expand_query(self, query, season=None):
        if season is None:
            season = self.get_current_season()
        
        # 원래 쿼리 토큰화
        query_terms = query.split()
        expanded_terms = []
        
        # 계절 사전에서 관련 용어 찾기
        for term in query_terms:
            if term in self.seasonal_dict[season]:
                expanded_terms.extend(self.seasonal_dict[season][term])
        
        # 중복 제거 및 원래 쿼리와 결합
        expanded_terms = list(set(expanded_terms))
        expanded_query = query + " " + " ".join(expanded_terms)
        return expanded_query

class UserProfileQueryExpander:
    def __init__(self):
        # 사용자 프로필 데이터베이스 예시
        self.user_profiles = {
            'user1': {
                'age_group': '20대',
                'gender': '여성',
                'interests': ['패션', '뷰티', '여행'],
                'purchase_history': ['원피스', '립스틱', '선크림'],
                'search_history': ['여름 원피스', '데일리 메이크업', '제주도 여행']
            },
            'user2': {
                'age_group': '30대',
                'gender': '남성',
                'interests': ['전자기기', '운동', '자동차'],
                'purchase_history': ['노트북', '운동화', '블루투스 이어폰'],
                'search_history': ['맥북 프로', '런닝화 추천', '전기차 비교']
            }
        }
        
        # 사용자 특성별 확장 사전
        self.gender_dict = {
            '여성': {
                '옷': ['여성복', '원피스', '블라우스', '스커트'],
                '신발': ['힐', '플랫슈즈', '로퍼', '샌들'],
                '가방': ['숄더백', '크로스백', '토트백']
            },
            '남성': {
                '옷': ['남성복', '셔츠', '정장', '티셔츠'],
                '신발': ['로퍼', '스니커즈', '구두', '워커'],
                '가방': ['백팩', '서류가방', '크로스백']
            }

        # 의도별 특화 용어 추가
        if has_purchase_intent:
            intent_terms.extend(['구매', '주문', '배송', '결제', '할인'])
        
        if has_comparison_intent:
            intent_terms.extend(['비교', '차이점', '장단점', '특징', '스펙'])
        
        if has_info_intent:
            intent_terms.extend(['상세정보', '사양', '기능', '사용법', '제원'])
        
        if has_review_intent:
            intent_terms.extend(['리뷰', '평점', '만족도', '인기상품', '베스트'])
        
        return intent_terms
    
    def expand_query(self, query, user_id=None):
        """이커머스 특화 쿼리 확장"""
        # Step 1: 오타 교정
        corrected_query, _ = self.spell_corrector.expand_query(query)
        
        # Step 2: 카테고리 및 브랜드 확장
        category_expanded = self.category_expander.expand_query(corrected_query)
        
        # Step 3: 계절 정보 고려
        season_expanded = self.seasonal_expander.expand_query(corrected_query)
        
        # Step 4: 사용자 의도 파악 및 관련 용어 추가
        intent_terms = self.get_intent_specific_terms(corrected_query)
        
        # Step 5: 사이즈, 색상, 가격대 변형 처리
        query_terms = corrected_query.split()
        variant_terms = []
        
        for term in query_terms:
            # 사이즈 변형 확인
            for size_type, variants in self.size_variants.items():
                if term in variants:
                    variant_terms.extend(variants)
            
            # 색상 변형 확인
            for color_type, variants in self.color_variants.items():
                if term in variants:
                    variant_terms.extend(variants)
            
            # 가격대 변형 확인
            for price_type, variants in self.price_segments.items():
                if term in variants:
                    variant_terms.extend(variants)
        
        # Step 6: 사용자 프로필 기반 개인화 (가능한 경우)
        user_terms = []
        if user_id and self.user_profiles and user_id in self.user_profiles:
            profile = self.user_profiles[user_id]
            
            # 최근 검색어 활용
            if 'recent_searches' in profile:
                for search in profile['recent_searches'][-5:]:  # 최근 5개
                    search_terms = search.split()
                    for term in query_terms:
                        if term in search_terms:
                            user_terms.extend(search_terms)
            
            # 구매 이력 활용
            if 'purchase_history' in profile:
                relevant_purchases = []
                for purchase in profile['purchase_history']:
                    for term in query_terms:
                        if term in purchase:
                            relevant_purchases.append(purchase)
                user_terms.extend(relevant_purchases)
        
        # 모든 확장 용어 결합
        category_terms = category_expanded.split()
        season_terms = season_expanded.split()
        
        all_expanded_terms = list(set(
            category_terms + 
            season_terms + 
            intent_terms + 
            variant_terms + 
            user_terms
        ) - set(query_terms))
        
        # 최종 확장 쿼리 생성
        expanded_query = corrected_query + " " + " ".join(all_expanded_terms)
        
        return expanded_query

class QAQueryExpander:
    def __init__(self, model="gpt-3.5-turbo"):
        """
        질의응답 시스템을 위한 쿼리 확장기
        
        Parameters:
        -----------
        model : str
            사용할 LLM 모델명
        """
        self.model = model
        
        # 질문 유형 분류
        self.question_types = {
            'factoid': ['누구', '언제', '어디', '무엇', '얼마나', '몇'],
            'definition': ['뜻', '의미', '정의', '개념'],
            'procedural': ['방법', '어떻게', '단계', '절차'],
            'causal': ['이유', '왜', '원인', '때문에'],
            'comparative': ['차이', '비교', '대비', '다른점', '같은점'],
            'opinion': ['생각', '의견', '관점', '평가', '전망']
        }
    
    def classify_question_type(self, query):
        """질문 유형 분류"""
        for q_type, indicators in self.question_types.items():
            if any(ind in query for ind in indicators):
                return q_type
        return 'general'
    
    def generate_reformulations(self, query, question_type):
        """질문 타입에 따른 재구성 생성"""
        prompt_templates = {
            'factoid': """
                다음 사실 확인 질문을 5가지 다른 방식으로 바꿔주세요:
                질문: "{query}"
                
                1.
                2.
                3.
                4.
                5.
            """,
            'definition': """
                다음 개념/정의 질문을 5가지 다른 방식으로 바꿔주세요:
                질문: "{query}"
                
                1.
                2.
                3.
                4.
                5.
            """,
            'procedural': """
                다음 절차/방법 질문을 5가지 다른 방식으로 바꿔주세요:
                질문: "{query}"
                
                1.
                2.
                3.
                4.
                5.
            """,
            'causal': """
                다음 원인/이유 질문을 5가지 다른 방식으로 바꿔주세요:
                질문: "{query}"
                
                1.
                2.
                3.
                4.
                5.
            """,
            'comparative': """
                다음 비교 질문을 5가지 다른 방식으로 바꿔주세요:
                질문: "{query}"
                
                1.
                2.
                3.
                4.
                5.
            """,
            'opinion': """
                다음 의견/평가 질문을 5가지 다른 방식으로 바꿔주세요:
                질문: "{query}"
                
                1.
                2.
                3.
                4.
                5.
            """,
            'general': """
                다음 질문을 5가지 다른 방식으로 바꿔주세요:
                질문: "{query}"
                
                1.
                2.
                3.
                4.
                5.
            """
        }
        
        prompt = prompt_templates[question_type].format(query=query)
        
        response = openai.ChatCompletion.create(
            model=self.model,
            messages=[
                {"role": "system", "content": "You are a helpful assistant that reformulates questions."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.7
        )
        
        # 응답 파싱
        result = response.choices[0].message.content.strip()
        lines = [line.strip() for line in result.split('\n') if line.strip()]
        
        reformulations = []
        for line in lines:
            if line[0].isdigit() and '. ' in line:
                # 번호 제거
                reformulation = line.split('. ', 1)[1].strip()
                reformulations.append(reformulation)
        
        # 원래 쿼리 추가
        reformulations.append(query)
        return reformulations
    
    def decompose_complex_question(self, query):
        """복잡한 질문을 하위 질문으로 분해"""
        prompt = f"""
        다음은 복잡한 질문 이 질문에 답하기 위해 필요한 하위 질문들로 분해해주세요:
        
        복잡한 질문: "{query}"
        
        하위 질문:
        1.
        """
        
        response = openai.ChatCompletion.create(
            model=self.model,
            messages=[
                {"role": "system", "content": "You are a helpful assistant that decomposes complex questions."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.7
        )
        
        # 응답 파싱
        result = response.choices[0].message.content.strip()
        lines = [line.strip() for line in result.split('\n') if line.strip()]
        
        sub_questions = []
        for line in lines:
            if line[0].isdigit() and '. ' in line:
                sub_question = line.split('. ', 1)[1].strip()
                sub_questions.append(sub_question)
        
        return sub_questions
    
    def expand_query(self, query):
        """QA 특화 쿼리 확장"""
        # 질문 유형 분류
        question_type = self.classify_question_type(query)
        
        # 질문 재구성
        reformulations = self.generate_reformulations(query, question_type)
        
        # 복잡한 질문인 경우 하위 질문으로 분해
        is_complex = len(query.split()) > 15 or '그리고' in query or '또한' in query
        
        if is_complex:
            sub_questions = self.decompose_complex_question(query)
            reformulations.extend(sub_questions)
        
        return reformulations

class MultilingualQueryExpander:
    def __init__(self, model="gpt-3.5-turbo", target_languages=None):
        """
        다국어 쿼리 확장기
        
        Parameters:
        -----------
        model : str
            사용할 LLM 모델명
        target_languages : list
            목표 언어 코드 리스트 (ISO 639-1)
        """
        self.model = model
        self.target_languages = target_languages or ['en', 'ko', 'ja', 'zh']
        
        # 언어 코드 매핑
        self.language_names = {
            'en': 'English',
            'ko': 'Korean',
            'ja': 'Japanese',
            'zh': 'Chinese',
            'es': 'Spanish',
            'fr': 'French',
            'de': 'German',
            'ru': 'Russian'
        }
    
    def detect_language(self, text):
        """텍스트 언어 감지 (간단한 구현)"""
        # 실제 구현에서는 langdetect 같은 라이브러리 사용 권장
        # 여기서는 간단한 휴리스틱 사용
        
        # 한글 확인
        if any('\uac00' <= char <= '\ud7a3' for char in text):
            return 'ko'
        
        # 일본어 확인
        if any('\u3040' <= char <= '\u30ff' for char in text):
            return 'ja'
        
        # 중국어 확인
        if any('\u4e00' <= char <= '\u9fff' for char in text):
            return 'zh'
        
        # 기본값: 영어
        return 'en'
    
    def translate_query(self, query, source_lang, target_lang):
        """쿼리 번역"""
        source_name = self.language_names.get(source_lang, source_lang)
        target_name = self.language_names.get(target_lang, target_lang)
        
        prompt = f"""
        Translate the following {source_name} query into {target_name}:
        
        Query: {query}
        
        {target_name} translation:
        """
        
        response = openai.ChatCompletion.create(
            model=self.model,
            messages=[
                {"role": "system", "content": "You are a helpful assistant that translates accurately."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.3
        )
        
        return response.choices[0].message.content.strip()
    
    def expand_in_language(self, query, language):
        """특정 언어로 쿼리 확장"""
        lang_name = self.language_names.get(language, language)
        
        prompt = f"""
        Expand the following {lang_name} query into 3 alternative queries in {lang_name}.
        The alternatives should capture different aspects or intents of the original query.
        
        Original query: {query}
        
        Alternative queries in {lang_name}:
        1.
        2.
        3.
        """
        
        response = openai.ChatCompletion.create(
            model=self.model,
            messages=[
                {"role": "system", "content": f"You are a helpful assistant that expands queries in {lang_name}."},
                {"role": "user", "content": prompt}
            ],
            temperature=0.7
        )
        
        # 응답 파싱
        result = response.choices[0].message.content.strip()
        lines = [line.strip() for line in result.split('\n') if line.strip()]
        
        expansions = []
        for line in lines:
            if line[0].isdigit() and '. ' in line:
                expansion = line.split('. ', 1)[1].strip()
                expansions.append(expansion)
        
        return expansions
    
    def expand_query(self, query):
        """다국어 쿼리 확장"""
        # 원본 쿼리 언어 감지
        source_lang = self.detect_language(query)
        
        all_expansions = [query]  # 원본 쿼리 포함
        
        # 1. 원본 언어로 확장
        same_lang_expansions = self.expand_in_language(query, source_lang)
        all_expansions.extend(same_lang_expansions)
        
        # 2. 다른 언어로 번역 및 확장 (설정된 언어만)
        for target_lang in self.target_languages:
            if target_lang != source_lang:
                # 번역
                translated = self.translate_query(query, source_lang, target_lang)
                all_expansions.append(translated)
                
                # 번역된 쿼리로 확장
                translated_expansions = self.expand_in_language(translated, target_lang)
                all_expansions.extend(translated_expansions)
        
        return all_expansions

import hashlib
import pickle
import os
import time

class QueryExpansionCache:
    def __init__(self, cache_dir='./cache', ttl=86400):
        """
        쿼리 확장 캐싱 시스템
        
        Parameters:
        -----------
        cache_dir : str
            캐시 파일 저장 디렉토리
        ttl : int
            캐시 항목 유효 시간 (초)
        """
        self.cache_dir = cache_dir
        self.ttl = ttl
        
        # 캐시 디렉토리 생성
        os.makedirs(cache_dir, exist_ok=True)
    
    def _get_cache_key(self, query, method_name):
        """캐시 키 생성"""
        key = f"{query}_{method_name}"
        return hashlib.md5(key.encode('utf-8')).hexdigest()
    
    def _get_cache_path(self, cache_key):
        """캐시 파일 경로 생성"""
        return os.path.join(self.cache_dir, f"{cache_key}.pkl")
    
    def get(self, query, method_name):
        """캐시에서 확장 쿼리 가져오기"""
        cache_key = self._get_cache_key(query, method_name)
        cache_path = self._get_cache_path(cache_key)
        
        if os.path.exists(cache_path):
            # 캐시 파일 존재 여부 확인
            file_age = time.time() - os.path.getmtime(cache_path)
            
            if file_age <= self.ttl:
                # TTL 내에 있는 캐시
                try:
                    with open(cache_path, 'rb') as f:
                        cache_data = pickle.load(f)
                    return cache_data
                except Exception as e:
                    print(f"캐시 로딩 오류: {e}")
            else:
                # 유효 기간 지난 캐시 삭제
                try:
                    os.remove(cache_path)
                except:
                    pass
        
        return None
    
    def set(self, query, method_name, expansion_data):
        """확장 쿼리 캐시에 저장"""
        cache_key = self._get_cache_key(query, method_name)
        cache_path = self._get_cache_path(cache_key)
        
        try:
            with open(cache_path, 'wb') as f:
                pickle.dump(expansion_data, f)
            return True
        except Exception as e:
            print(f"캐시 저장 오류: {e}")
            return False
    
    def clear_expired(self):
        """만료된 캐시 항목 정리"""
        now = time.time()
        cleared_count = 0
        
        for filename in os.listdir(self.cache_dir):
            if filename.endswith('.pkl'):
                file_path = os.path.join(self.cache_dir, filename)
                file_age = now - os.path.getmtime(file_path)
                
                if file_age > self.ttl:
                    try:
                        os.remove(file_path)
                        cleared_count += 1
                    except:
                        pass
        
        return cleared_count

class CachedQueryExpander:
    def __init__(self, expander, cache=None):
        """
        캐싱을 지원하는 쿼리 확장기 래퍼
        
        Parameters:
        -----------
        expander : object
            실제 쿼리 확장을 수행하는 객체
        cache : QueryExpansionCache
            캐시 객체 (기본값: 새 캐시 생성)
        """
        self.expander = expander
        self.cache = cache or QueryExpansionCache()
        self.method_name = expander.__class__.__name__
    
    def expand_query(self, query, **kwargs):
        """캐싱 지원 쿼리 확장"""
        # 캐시 조회
        cache_key = f"{query}_{str(kwargs)}"
        cached_result = self.cache.get(cache_key, self.method_name)
        
        if cached_result is not None:
            return cached_result
        
        # 캐시 없으면 실제 확장 수행
        expanded = self.expander.expand_query(query, **kwargs)
        
        # 결과 캐싱
        self.cache.set(cache_key, self.method_name, expanded)
        
        return expanded

import random
import uuid
import datetime
import json

class QueryExpansionABTest:
    def __init__(self, expanders, test_name, test_duration_days=7):
        """
        쿼리 확장 A/B 테스트 프레임워크
        
        Parameters:
        -----------
        expanders : dict
            테스트할 확장기 {variant_name: expander_object}
        test_name : str
            테스트 이름
        test_duration_days : int
            테스트 기간 (일)
        """
        self.expanders = expanders
        self.test_name = test_name
        self.variants = list(expanders.keys())
        
        # 테스트 설정
        self.start_time = datetime.datetime.now()
        self.end_time = self.start_time + datetime.timedelta(days=test_duration_days)
        
        # 결과 저장소
        self.results_file = f"ab_test_{test_name}_{self.start_time.strftime('%Y%m%d')}.json"
        self.session_variant_map = {}  # 세션별 할당된 변형
        self.events = []  # 이벤트 로그
    
    def is_active(self):
        """테스트 활성 여부 확인"""
        return datetime.datetime.now() < self.end_time
    
    def assign_variant(self, session_id):
        """세션에 변형 할당"""
        if not self.is_active():
            # 테스트 종료 시 기본 변형 사용
            return self.variants[0]
        
        if session_id in self.session_variant_map:
            # 이미 할당된 세션은 동일 변형 유지
            return self.session_variant_map[session_id]
        
        # 새 세션에 무작위 변형 할당
        variant = random.choice(self.variants)
        self.session_variant_map[session_id] = variant
        
        # 할당 이벤트 기록
        self._log_event(session_id, 'assignment', {'variant': variant})
        
        return variant
    
    def expand_query(self, query, session_id=None):
        """세션별 변형에 따른 쿼리 확장"""
        if session_id is None:
            session_id = str(uuid.uuid4())
        
        # 변형 할당
        variant = self.assign_variant(session_id)
        expander = self.expanders[variant]
        
        # 쿼리 확장 실행
        try:
            start_time = datetime.datetime.now()
            expanded = expander.expand_query(query)
            duration = (datetime.datetime.now() - start_time).total_seconds()
            
            # 확장 이벤트 기록
            self._log_event(session_id, 'expansion', {
                'variant': variant,
                'original_query': query,
                'expanded_query': expanded,
                'duration': duration
            })
            
            return expanded
        except Exception as e:
            # 오류 이벤트 기록
            self._log_event(session_id, 'error', {
                'variant': variant,
                'original_query': query,
                'error': str(e)
            })
            return query  # 오류 시 원래 쿼리 반환
    
    def record_click(self, session_id, query, doc_id, position):
        """검색 결과 클릭 기록"""
        self._log_event(session_id, 'click', {
            'query': query,
            'doc_id': doc_id,
            'position': position,
            'variant': self.session_variant_map.get(session_id)
        })
    
    def record_conversion(self, session_id, query, conversion_type, value=None):
        """전환 이벤트 기록"""
        self._log_event(session_id, 'conversion', {
            'query': query,
            'conversion_type': conversion_type,
            'value': value,
            'variant': self.session_variant_map.get(session_id)
        })
    
    def _log_event(self, session_id, event_type, data):
        """이벤트 로깅"""
        event = {
            'timestamp': datetime.datetime.now().isoformat(),
            'session_id': session_id,
            'event_type': event_type,
            'test_name': self.test_name,
            'data': data
        }
        self.events.append(event)
        
        # 주기적으로 이벤트 저장
        if len(self.events) >= 100:
            self.save_events()
    
    def save_events(self):
        """이벤트 파일 저장"""
        try:
            # 기존 이벤트 로드
            existing_events = []
            if os.path.exists(self.results_file):
                with open(self.results_file, 'r', encoding='utf-8') as f:
                    existing_events = json.load(f)
            
            # 새 이벤트 추가
            all_events = existing_events + self.events
            
            # 파일 저장
            with open(self.results_file, 'w', encoding='utf-8') as f:
                json.dump(all_events, f, ensure_ascii=False, indent=2)
            
            # 저장 후 이벤트 초기화
            self.events = []
            
            return True
        except Exception as e:
            print(f"이벤트 저장 오류: {e}")
            return False
    
    def get_results(self):
        """테스트 결과 분석"""
        self.save_events()  # 모든 이벤트 저장
        
        # 파일에서 이벤트 로드
        try:
            with open(self.results_file, 'r', encoding='utf-8') as f:
                events = json.load(f)
        except:
            events = []
        
        # 변형별 통계
        stats = {variant: {
            'assignments': 0,
            'expansions': 0,
            'errors': 0,
            'clicks': 0,
            'conversions': 0,
            'avg_duration': 0,
            'ctr': 0,
            'cvr': 0
        } for variant in self.variants}
        
        # 세션별 정보
        sessions = {}
        
        # 이벤트 처리
        for event in events:
            event_type = event['event_type']
            session_id = event['session_id']
            data = event['data']
            variant = data.get('variant')
            
            if not variant or variant not in stats:
                continue
            
            # 세션 정보 초기화
            if session_id not in sessions:
                sessions[session_id] = {'impressions': 0, 'clicks': 0, 'conversions': 0}
            
            # 이벤트 유형별 처리
            if event_type == 'assignment':
                stats[variant]['assignments'] += 1
            
            elif event_type == 'expansion':
                stats[variant]['expansions'] += 1
                stats[variant]['avg_duration'] += data.get('duration', 0)
                sessions[session_id]['impressions'] += 1
            
            elif event_type == 'error':
                stats[variant]['errors'] += 1
            
            elif event_type == 'click':
                stats[variant]['clicks'] += 1
                sessions[session_id]['clicks'] += 1
            
            elif event_type == 'conversion':
                stats[variant]['conversions'] += 1
                sessions[session_id]['conversions'] += 1
        
        # 평균 및 비율 계산
        for variant, data in stats.items():
            if data['expansions'] > 0:
                data['avg_duration'] /= data['expansions']
            
            if data['expansions'] > 0:
                data['ctr'] = data['clicks'] / data['expansions']
            
            if data['clicks'] > 0:
                data['cvr'] = data['conversions'] / data['clicks']
        
        return {
            'test_name': self.test_name,
            'start_time': self.start_time.isoformat(),
            'end_time': self.end_time.isoformat(),
            'active': self.is_active(),
            'variants': self.variants,
            'stats': stats
        }

class OnlineQueryExpansionLearner:
    def __init__(self, base_expander, learning_rate=0.1, feedback_window=100):
        """
        온라인 학습 쿼리 확장 시스템
        
        Parameters:
        -----------
        base_expander : object
            기본 쿼리 확장기
        learning_rate : float
            학습률 (0~1)
        feedback_window : int
            피드백 윈도우 크기
        """
        self.base_expander = base_expander
        self.learning_rate = learning_rate
        self.feedback_window = feedback_window
        
        # 용어 가중치 관리
        self.term_weights = {}  # {term: weight}
    
        # 피드백 이력
        self.feedback_history = []  # [(query, expanded_terms, clicked_doc, rating)]
        
        # 용어 추출기
        self.tokenizer = lambda text: text.lower().split()
    
    def expand_query(self, query):
        """가중치 적용 쿼리 확장"""
        # 기본 확장기로 확장
        base_expanded = self.base_expander.expand_query(query)
        
        if isinstance(base_expanded, list):
            # 리스트인 경우 (여러 확장 쿼리)
            expanded_terms = []
            for exp_query in base_expanded:
                expanded_terms.extend(self.tokenizer(exp_query))
        else:
            # 문자열인 경우 (단일 확장 쿼리)
            expanded_terms = self.tokenizer(base_expanded)
        
        # 원래 쿼리 용어 제외
        query_terms = set(self.tokenizer(query))
        expanded_terms = [term for term in expanded_terms if term not in query_terms]
        
        # 가중치 적용 및 정렬
        weighted_terms = []
        for term in expanded_terms:
            weight = self.term_weights.get(term, 1.0)
            weighted_terms.append((term, weight))
        
        # 가중치 기준 정렬
        weighted_terms.sort(key=lambda x: x[1], reverse=True)
        
        # 상위 10개 용어 선택
        top_terms = [term for term, _ in weighted_terms[:10]]
        
        # 최종 확장 쿼리 생성
        final_expanded = query + " " + " ".join(top_terms)
        
        return final_expanded, top_terms
    
    def record_feedback(self, query, expanded_terms, clicked_doc=None, rating=None):
        """사용자 피드백 기록"""
        # 피드백 추가
        feedback = (query, expanded_terms, clicked_doc, rating)
        self.feedback_history.append(feedback)
        
        # 윈도우 크기 유지
        if len(self.feedback_history) > self.feedback_window:
            self.feedback_history.pop(0)
        
        # 가중치 업데이트
        self._update_weights()
        
        return len(self.feedback_history)
    
    def _update_weights(self):
        """피드백 기반 용어 가중치 업데이트"""
        # 모든 용어의 점수 계산
        term_scores = {}
        
        for query, expanded_terms, clicked_doc, rating in self.feedback_history:
            if clicked_doc is not None:
                # 클릭 피드백이 있는 경우
                clicked_terms = self.tokenizer(clicked_doc)
                
                for term in expanded_terms:
                    # 클릭된 문서에 용어가 있으면 긍정 피드백
                    if term in clicked_terms:
                        if term not in term_scores:
                            term_scores[term] = 0
                        term_scores[term] += 1
            
            if rating is not None:
                # 명시적 평점이 있는 경우 (-1 ~ 1 범위)
                for term in expanded_terms:
                    if term not in term_scores:
                        term_scores[term] = 0
                    term_scores[term] += rating
        
        # 가중치 업데이트 (지수 이동 평균)
        for term, score in term_scores.items():
            if term not in self.term_weights:
                self.term_weights[term] = 1.0
            
            # 점수 정규화 (-1 ~ 1 범위)
            normalized_score = max(min(score, 1.0), -1.0)
            
            # 가중치 업데이트
            self.term_weights[term] = (1 - self.learning_rate) * self.term_weights[term] + self.learning_rate * (1 + normalized_score)
            
            # 가중치 범위 제한 (0.1 ~ 2.0)
            self.term_weights[term] = max(min(self.term_weights[term], 2.0), 0.1)
    
    def get_term_weights(self, top_n=20):
        """상위 n개 용어 가중치 조회"""
        sorted_weights = sorted(self.term_weights.items(), key=lambda x: x[1], reverse=True)
        return sorted_weights[:top_n]
    
    def save_model(self, filename):
        """모델 저장"""
        model_data = {
            'term_weights': self.term_weights,
            'learning_rate': self.learning_rate,
            'feedback_window': self.feedback_window
        }
        
        with open(filename, 'wb') as f:
            pickle.dump(model_data, f)
        
        return True
    
    def load_model(self, filename):
        """모델 로드"""
        try:
            with open(filename, 'rb') as f:
                model_data = pickle.load(f)
            
            self.term_weights = model_data['term_weights']
            self.learning_rate = model_data['learning_rate']
            self.feedback_window = model_data['feedback_window']
            
            return True
        except Exception as e:
            print(f"모델 로딩 오류: {e}")
            return False

from transformers import AutoTokenizer, AutoModel
import torch
import numpy as np

class BERTQueryExpander:
    def __init__(self, model_name="klue/bert-base", device=None):
        """
        BERT 기반 쿼리 확장기
        
        Parameters:
        -----------
        model_name : str
            사용할 BERT 모델명
        device : str
            실행 디바이스 ('cuda' 또는 'cpu')
        """
        self.device = device or ('cuda' if torch.cuda.is_available() else 'cpu')
        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
        self.model = AutoModel.from_pretrained(model_name).to(self.device)
        
        # 랭킹 모델 설정
        self._init_ranker()
    
    def _init_ranker(self):
        """MLM 랭킹 모델 초기화"""
        from transformers import BertForMaskedLM
        self.mlm_model = BertForMaskedLM.from_pretrained("klue/bert-base").to(self.device)
        self.mlm_model.eval()
    
    def get_embeddings(self, text):
        """BERT 임베딩 생성"""
        inputs = self.tokenizer(text, return_tensors="pt", padding=True, truncation=True, max_length=512)
        inputs = {k: v.to(self.device) for k, v in inputs.items()}
        
        with torch.no_grad():
            outputs = self.model(**inputs)
        
        # [CLS] 토큰 임베딩 사용
        return outputs.last_hidden_state[:, 0, :].cpu().numpy()
    
    def find_similar_terms(self, query_terms, candidate_terms, top_k=10):
        """의미적으로 유사한 용어 찾기"""
        query_emb = self.get_embeddings(" ".join(query_terms))
        
        similarities = []
        for term in candidate_terms:
            term_emb = self.get_embeddings(term)
            # 코사인 유사도 계산
            sim = np.dot(query_emb, term_emb.T) / (np.linalg.norm(query_emb) * np.linalg.norm(term_emb))
            similarities.append((term, float(sim)))
        
        # 유사도 기준 정렬
        similarities.sort(key=lambda x: x[1], reverse=True)
        
        return similarities[:top_k]
    
    def predict_masked_terms(self, query, num_predictions=5):
        """마스크 예측으로 용어 생성"""
        # 쿼리에 [MASK] 토큰 추가
        masked_query = query + " " + self.tokenizer.mask_token
        
        inputs = self.tokenizer(masked_query, return_tensors="pt")
        inputs = {k: v.to(self.device) for k, v in inputs.items()}
        
        # 마스크 토큰 위치 찾기
        mask_token_index = torch.where(inputs["input_ids"] == self.tokenizer.mask_token_id)[1]
        
        with torch.no_grad():
            outputs = self.mlm_model(**inputs)
        
        # 마스크 위치의 예측 가져오기
        logits = outputs.logits
        mask_token_logits = logits[0, mask_token_index, :]
        
        # 상위 예측 선택
        top_tokens = torch.topk(mask_token_logits, num_predictions, dim=1).indices[0].tolist()
        
        # 토큰 디코딩
        predicted_terms = [self.tokenizer.decode([token]) for token in top_tokens]
        
        return predicted_terms
    
    def expand_query(self, query, candidate_pool=None, num_terms=10):
        """BERT 기반 쿼리 확장"""
        # 쿼리 토큰화
        query_terms = query.lower().split()
        
        # 후보 풀이 없으면 마스크 예측 사용
        if candidate_pool is None:
            predicted_terms = []
            # 여러 위치에 마스크 추가하여 예측
            for i in range(min(len(query_terms) + 1, 3)):  # 최대 3개 위치
                if i < len(query_terms):
                    # 기존 단어 대체
                    context = " ".join(query_terms[:i] + [self.tokenizer.mask_token] + query_terms[i+1:])
                else:
                    # 문장 끝에 추가
                    context = query + " " + self.tokenizer.mask_token
                
                inputs = self.tokenizer(context, return_tensors="pt")
                inputs = {k: v.to(self.device) for k, v in inputs.items()}
                mask_token_index = torch.where(inputs["input_ids"] == self.tokenizer.mask_token_id)[1]
                
                with torch.no_grad():
                    outputs = self.mlm_model(**inputs)
                
                logits = outputs.logits
                mask_token_logits = logits[0, mask_token_index, :]
                top_tokens = torch.topk(mask_token_logits, 5, dim=1).indices[0].tolist()
                
                for token in top_tokens:
                    term = self.tokenizer.decode([token]).strip()
                    if term not in query_terms and len(term) > 1:
                        predicted_terms.append(term)
            
            # 중복 제거
            predicted_terms = list(set(predicted_terms))
            
            # 유사도 기준 정렬
            similar_terms = self.find_similar_terms(query_terms, predicted_terms)
            
            # 최종 확장 용어 선택
            expansion_terms = [term for term, _ in similar_terms[:num_terms]]
        else:
            # 후보 풀이 있으면 유사도 기반 선택
            similar_terms = self.find_similar_terms(query_terms, candidate_pool)
            expansion_terms = [term for term, _ in similar_terms[:num_terms]]
        
        # 최종 확장 쿼리 생성
        expanded_query = query + " " + " ".join(expansion_terms)
        
        return expanded_query