Upload 8 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+final_prod_data.csv filter=lfs diff=lfs merge=lfs -text
+final_review_df.csv filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,982 @@
+# -*- coding: utf-8 -*-
+"""app.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1hl-apQjNm2ijxBoDj-PV0ua7-4taVJo2
+"""
+
+import os
+import sys
+
+__import__('pysqlite3')
+import sys
+sys.modules['sqlite3'] = sys.modules.pop('pysqlite3')
+
+import shutil
+import torch
+import re
+import chromadb
+from langchain_chroma import Chroma
+import pandas as pd
+import gradio as gr
+import ast
+import numpy as np
+from PIL import Image
+from collections import Counter, defaultdict
+from transformers import CLIPProcessor, CLIPModel
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import PromptTemplate
+from sentence_transformers import util
+
+import sys
+import gspread
+from oauth2client.service_account import ServiceAccountCredentials
+import datetime
+import json
+
+# [1] 구글 시트 연결 설정 함수
+def get_google_sheet():
+    # 1. 인증 범위 설정
+    scope = ['https://spreadsheets.google.com/feeds', 'https://www.googleapis.com/auth/drive']
+    # 2. 다운받은 키 파일 이름 (같은 폴더에 있어야 함)
+    creds = ServiceAccountCredentials.from_json_keyfile_name('fashion_key.json', scope)
+    client = gspread.authorize(creds)
+
+    # 3. 스프레드시트 열기 (공유한 파일 이름 정확히 입력!)
+    sh = client.open('패션추천시스템_사용자정보')
+    return sh
+
+# [2] 검색 데이터 저장 함수 (시트1에 저장)
+def log_search_to_sheet(bg, cat, min_p, max_p, style, txt, check, persona):
+    try:
+        sh = get_google_sheet()
+        worksheet = sh.get_worksheet(0) # 첫 번째 시트 선택
+
+        # 헤더가 없으면 추가 (옵션)
+        if not worksheet.row_values(1):
+            worksheet.append_row(['시간', '브랜드', '카테고리', '최소가격', '최대가격', '스타일', '텍스트', '성별교차', '결과페르소나'])
+
+        # 데이터 추가
+        timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        worksheet.append_row([timestamp, bg, cat, min_p, max_p, style, txt, "O" if check else "X", persona])
+    except Exception as e:
+        print(f"구글 시트 저장 실패: {e}")
+
+# [3] 사이즈 추천 데이터 저장 함수 (시트2에 저장)
+def log_size_to_sheet(sel_product, u_info, rec_size, reason):
+    try:
+        sh = get_google_sheet()
+        # 두 번째 시트가 없으면 생성, 있으면 가져오기
+        try:
+            worksheet = sh.get_worksheet(1)
+        except:
+            worksheet = sh.add_worksheet(title="사이즈추천", rows="100", cols="20")
+
+        if not worksheet.row_values(1):
+            worksheet.append_row(['시간', '선택상품', '유저정보', '추천사이즈', '추천이유'])
+
+        timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        user_info_str = json.dumps(u_info, ensure_ascii=False)
+        worksheet.append_row([timestamp, sel_product, user_info_str, rec_size, reason])
+    except Exception as e:
+        print(f"구글 시트 저장 실패: {e}")
+
+os.environ["OPENAI_API_KEY"] = os.environ.get("OPENAI_API_KEY")
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+base_path = "."
+
+product_db_path = os.path.join(base_path, "product_db")
+review_db_path = os.path.join(base_path, "review_db")
+style_db_path = os.path.join(base_path, "style_db")
+
+product_csv_path = os.path.join(base_path, "final_prod_data.csv")
+size_csv_path = os.path.join(base_path, "size_sorted.csv")
+review_csv_path = os.path.join(base_path, "final_review_df.csv")
+
+
+try:
+    prod_data = pd.read_csv(product_csv_path)
+    prod_data['primary_id'] = prod_data['primary_id'].astype(str)
+except:
+    prod_data = pd.DataFrame()
+
+try:
+    prod_size_df = pd.read_csv(size_csv_path)
+    prod_size_df = prod_size_df.replace('-', np.nan)
+    prod_size_df['primary_id'] = prod_size_df['primary_id'].astype(str)
+except:
+    prod_size_df = pd.DataFrame()
+
+try:
+    review_df = pd.read_csv(review_csv_path)
+    review_df['primary_id'] = review_df['primary_id'].astype(int)
+    review_ids = set(review_df['primary_id'].astype(str))
+except:
+    print(f"리뷰 데이터 로드 실패: {e}")
+    review_ids = set()
+
+clip_model = CLIPModel.from_pretrained("patrickjohncyh/fashion-clip").to(device)
+clip_processor = CLIPProcessor.from_pretrained("patrickjohncyh/fashion-clip")
+
+review_emb_func = HuggingFaceEmbeddings(
+    model_name='jhgan/ko-sroberta-multitask',
+    model_kwargs={'device': device},
+    encode_kwargs={'normalize_embeddings': True}
+)
+
+llm = ChatOpenAI(model = "gpt-4o-mini", temperature=0.7) # 결과값 확인 후 temperature 값 조정 필요
+
+try:
+    product_client = chromadb.PersistentClient(path=product_db_path)
+    product_collection = product_client.get_collection("product_vectorstore")
+except Exception as e:
+    print(f"{e} DB 연결 실패")
+
+try:
+    style_client = chromadb.PersistentClient(path=style_db_path)
+    style_collection = style_client.get_collection("style_vectorstore")
+except Exception as e:
+    print(f"{e} DB 연결 실패")
+
+try:
+    review_db = Chroma(
+        persist_directory=review_db_path,
+        embedding_function=review_emb_func,
+        collection_name="review_vectorstore"
+    )
+except Exception as e:
+    print(f"{e} DB 연결 실패")
+
+def get_style_options():
+    try:
+        data = style_collection.get(include=["metadatas"], limit=9999)
+        names = [m.get("display_name") for m in data["metadatas"] if m.get("display_name")]
+        names = sorted(set(names))
+
+        return ["선택 안 함"] + names
+
+    except Exception as e:
+        print("ERROR in get_style_options:", e)
+        return ["선택 안 함"]
+
+style_key_options = get_style_options()
+
+'''
+추천 상품의 사이즈와 유사도 점수 가장 높은 상품의 추천 사이즈 간 유클리디언 거리 측정
+(단, 추천 상품의 사이즈 데이터가 하나 밖에 없을 경우 상세 사이즈 수치만 제시)
+'''
+def set_fin_size(id, size_label):
+    '''
+    [1단계] 유사도 점수가 가장 높은 상품 사이즈의 row 가져오기
+    '''
+    if prod_size_df.empty:
+        return None
+
+    try:
+        r = prod_size_df[
+            (prod_size_df['primary_id'] == str(id)) &
+            (prod_size_df['size_cleaned'].astype(str) == str(size_label))
+        ]
+        if r.empty:
+            return None
+
+        numeric_cols = r.select_dtypes(include=[np.number]).columns.tolist()
+        numeric_cols = [c for c in numeric_cols if c not in ['primary_id']]
+
+        return r.iloc[0][numeric_cols].to_dict()
+    except:
+        return None
+
+def find_closest_size(target_id, ideal_spec):
+    '''
+    [2단계] 추천 상품의 사이즈 중 ideal_spec에 가장 가까운 사이즈 찾기
+    '''
+    if prod_size_df.empty or not ideal_spec:
+        return None
+
+    target_r = prod_size_df[prod_size_df['primary_id'] == str(target_id)]
+    if target_r.empty:
+        return None
+
+    if len(target_r) == 1:
+        only_size = target_r.iloc[0]['size_cleaned']
+        return only_size
+
+    if not ideal_spec:
+        return None
+
+    min_dist = float('inf')
+    best_size = None
+    common_keys = [k for k in ideal_spec.keys() if k in target_r.columns]
+
+    if not common_keys:
+        return None
+
+    for _, row in target_r.iterrows():
+        try:
+            c_specs = [float(ideal_spec[k]) for k in common_keys if pd.notna(row[k])]
+            t_specs = [float(row[k]) for k in common_keys if pd.notna(row[k])]
+
+            if not c_specs or len(c_specs) != len(t_specs):
+                continue
+
+            dist = np.linalg.norm(np.array(c_specs) - np.array(t_specs))
+            if dist < min_dist:
+                min_dist = dist
+                best_size = row['size_cleaned']
+        except:
+            continue
+
+    return best_size
+
+def search_recom_products(brand_lb, cat,
+                          sel_key, txt, img, user_info,
+                          min_price, max_price, check_option):
+#=================================================================================
+# 추천 1단계: 프롬프트에 입력된 스타일 값을 바탕으로 벡터 유사도 계산 후 top-5개 추천
+#================================================================================
+    query_vec, source = get_search_vector(sel_key, txt, img)
+    if query_vec is None:
+        return [], "검색 조건을 입력하세요", {}, "", []
+
+    gender_option = [user_info['gender'], 'all'] # 남성: male, 여성: female, 공용: all nan: all로 바꾸기
+
+    filter = {
+      "$and": [
+              {"brand_label": {"$eq": brand_lb}},
+              {"sub_category": {"$eq": cat}}
+              ]
+    }
+
+    if min_price is not None and max_price is not None:
+        if min_price > max_price:
+            min_price, max_price = max_price, min_price
+        filter["$and"].append({"price": {"$gte": min_price}})
+        filter["$and"].append({"price": {"$lte": max_price}})
+
+    if not check_option:
+        filter["$and"].append({"gender": {"$in": gender_option}})
+
+
+    candidates = product_collection.query(
+        query_embeddings=[query_vec],
+        n_results=20,
+        where=filter,
+        include=["metadatas", "embeddings", "distances"]
+    )
+
+    if not candidates['ids'][0]:
+        return [], "조건에 맞는 상품이 없습니다.", {}, "", []
+
+    candidate_list_text = ""
+    candidate_map = {}
+
+    for i, meta in enumerate(candidates['metadatas'][0]):
+        p_id = meta.get('primary_id')
+        name = meta.get('product_name')
+        brand = meta.get('brand')
+        price = meta.get('price')
+        dist = candidates['distances'][0][i]
+        sim = 1 / (1 + dist) # 유사도 점수로 변환
+
+        candidate_list_text += f"[{i+1}] ID: {p_id} | 브랜드: {brand} | 제품명: {name} | 스타일유사도: {sim:.4f}\n"
+
+        candidate_map[str(i+1)] = {
+        "id": p_id, "name": name, "brand": brand, "price": price,
+        "cat": meta.get('sub_category'), "brand_lb": meta.get('brand_label'),
+        "idx": i
+        }
+
+    print(candidate_map)
+    style_requests = []
+
+    if txt:
+        style_requests.append(f"텍스트 요청: '{txt}'")
+
+    if sel_key and sel_key != '선택 안 함':
+        style_key_data = style_collection.get(
+            where={"display_name": {"$eq": sel_key}},
+            include=["metadatas"]
+        )
+        if style_key_data["metadatas"]:
+            style_desc = style_key_data["metadatas"][0].get("description")
+            if style_desc:
+                style_requests.append(f"선택 스타일 키워드 설명: '{style_desc}'")
+
+    if img is not None:
+        style_requests.append("이미지 기반 스타일 검색 포함")
+
+    if style_requests:
+        user_input_str = ", ".join(style_requests)
+
+    # 브랜드 라벨도 추가해서 특정 무드의 브랜드들을 선호하는 소비자의 성향 반영 필
+    selection_persona_prompt = PromptTemplate.from_template("""
+    당신은 전문 패션 MD입니다.
+    사용자 프로필과 스타일 유사도 데이터를 바탕으로 선정된 후보 목록 20개를 분석하여, 가장 적합한 **제품 5개를 선정**하고 **패션 페르소나**를 정의하세요.
+
+    [사용자 프로필]
+    - 성별/체형: {g} / {h}cm / {w}kg
+    - 선호 스타일 요청: "{s}"
+
+    [후보 제품 목록 (유사도 순)]
+    {c_list}
+
+    [사고 과정 (Chain of thought)]
+    1. 사용자 분석: 사용자 프로필 정보를 고려하여 사용자의 성별/체형에서 사용자의 선호 스타일을 표현하기 위해서는 어떤 실루엣, 소재, 디자인이 가장 적합한지를 기준을 세우세요.
+    2. 추천 제품 선정: 위에서 세운 기준에 근거하여 사용자에게 가장 적합한 제품 5개를 선정하세요. (단순 유사도 순이 아닌, 스타일 적합성 우선)
+    3. 페르소나 도출: 선별된 5개 제품과 사용자의 특징을 종합하여, 이 사용자가 추구하는 패션 아이덴티티(페르소나)를 구체적인 코디 예시를 들어 묘사합니다.
+
+    [출력 형식 및 제약 사]
+    1. 사고 과정(설명)은 출력하지 말고, 오직 **결과 데이터**만 아래 형식으로 출력하세요.
+    2. 제품번호는 후보 목록에 표시된 **순번(숫자)**만 적으세요.
+
+    SELECTED_IDS = [순번1, 순번2, 순번3, 순번4, 순번5]
+    |||
+    PERSONA = (여기에 3줄 내외의 페르소나 정의 작성)
+    """)
+
+    print("LLM이 제품을 선별 및 페르소나 생성 중...")
+    selection_response = llm.invoke(selection_persona_prompt.format(
+        g=user_info['gender'], h=user_info['height'], w=user_info['weight'],
+        s=user_input_str, c_list=candidate_list_text
+    )).content
+
+    try:
+        parts = selection_response.split("|||")
+
+        ids_text = parts[0]
+        selected_idx = re.findall(r'\d+', ids_text)
+        selected_idx = [idx for idx in selected_idx if idx in candidate_map]
+
+        persona_text = parts[1].replace("PERSONA =", "").strip()
+
+    except Exception as e:
+        print(f"파싱 오류: {e}")
+
+    if not selected_idx:
+        selected_idx = list(candidate_map.keys())[:5]
+
+    print("LLM 선택 응답:", selection_response)
+    print("candidate_map keys:", list(candidate_map.keys()))
+    print("selected_idx after filtering:", selected_idx)
+
+    user_info['p'] = persona_text
+
+    final_recom_item = []
+    p_map = {}
+
+    for idx_str in selected_idx[:5]:
+        item_data = candidate_map[idx_str]
+        img_url = get_img_url(item_data['id'])
+        label = f"[{item_data['brand']}]_{item_data['name']}] - {item_data['price']}원"
+
+        final_recom_item.append((img_url, label))
+        final_recom_item_gr = [[url if url else "", str(label)] for url, label in final_recom_item]
+        # Gradio Gallery, Image에 데이터를 넣을 때는 list 형태로 들어가야 됨
+        p_map[label] = item_data
+
+    print("Gallery 데이터:", final_recom_item_gr)
+    return final_recom_item_gr, user_info['p'], p_map, user_info
+
+def get_sim_products(target_id, category, brand_label=None, limit=5):
+  #========================================================================================
+  # 추천 2단계: 사이즈 추천 로직
+  # (추천 제품과  유사도 높은 제품 구하는 로직: 추천 제품의 리뷰가 임계치 이하일 경우 로직 작동)
+  #========================================================================================
+    target_data = product_collection.get(
+        ids=[target_id], include=['embeddings', 'metadatas'])
+
+    embs = target_data.get('embeddings')
+    if embs is None or len(embs) == 0:
+        return {}
+
+    target_img = torch.tensor(embs[0], dtype=torch.float32)
+    try:
+        meta_size = target_data['metadatas'][0].get('size_vec', '[]') #오 뭐야 왜 size_vec이 없냐
+        target_size = torch.tensor(ast.literal_eval(meta_size), dtype=torch.float32)
+    except:
+        return {}
+
+    review_ids_list = list(review_ids)
+    filter = {"$and": [{"sub_category": {"$eq": category}},
+                       {"primary_id": {"$in": review_ids_list}}, # primary_key save_type 문제 flaot타입으로 저장되어서 맞는게 없음
+                       {"review_count": { "$gt": 0 }}]}
+
+    if brand_label is not None:
+        filter["$and"].append({"brand_label": {"$eq": brand_label}})
+
+    candidates = product_collection.get(
+        where=filter, include=['embeddings', 'metadatas'])
+
+    cand_ids = candidates.get('ids')
+    if cand_ids is None or len(cand_ids) == 0:
+        return {}
+
+    valid_idx, candi_img, candi_size = [], [], []
+    for i, p_id in enumerate(cand_ids):
+        try:
+            v_str = candidates['metadatas'][i].get('size_vec')
+            if v_str:
+                v = ast.literal_eval(v_str)
+                if v:
+                    candi_size.append(v)
+                    candi_img.append(candidates['embeddings'][i])
+                    valid_idx.append(i)
+        except:
+            continue
+
+    if not valid_idx:
+        return {}
+
+    cand_img_vec = torch.tensor(np.array(candi_img), dtype=torch.float32)
+    cand_size_vec = torch.tensor(np.array(candi_size), dtype=torch.float32)
+
+    scores = (util.cos_sim(target_img, cand_img_vec)[0] * 0.6) + \
+              (util.cos_sim(target_size, cand_size_vec)[0] * 0.4)
+
+    top_k = torch.argsort(scores, descending=True)[:limit].tolist()
+
+    result_map = {}
+    for i in top_k:
+        real_idx = valid_idx[i]
+        p_id = cand_ids[real_idx]
+        score = float(scores[i])
+        result_map[p_id] = score
+
+    print(result_map)
+
+    return result_map
+
+def recom_size(label, p_map, user_info):
+    '''
+    추천 2단계: 사이즈 추천 로직
+    '''
+    # 유저가 상품 선택 후 선택 상품의 한해 사이즈 추천 진행
+    if not label:
+        return "상품을 먼저 선택해주세요"
+    if label not in p_map:
+        return f"오류: 선택한 제품 '{label}'의 데이터를 찾을 수 없습니다.\n(검색을 다시 하거나 다른 제품을 선택해보세요)", ""
+
+    if user_info is None:
+        user_info = {}
+    else:
+        user_info = dict(user_info)
+
+    target_id, cat, bl = p_map[label]['id'], p_map[label]['cat'], p_map[label]['brand_lb']
+
+    # 유저 페르소나의 리뷰와 유사도 계산
+    hyde_prompt = PromptTemplate.from_template("""
+당신은 지금부터 아래 프로필을 가진 사용자가 되어, 방금 구매한 옷에 대해 **만족한 후기**를 작성해야 합니다.
+
+[사용자 프로필]
+- 성별: {g}
+- 신체 스펙: {h}cm / {w}kg
+- 사용자 페르소나: {p}
+
+[구매한 상품 정보]
+- 제품 기본 정보: {p_info}
+- 카테고리: {cat} (예: 후드티, 와이드 슬랙스)
+
+[작성 지침]
+1. 당신의 신체 스펙과 선호 스타일을 고려하여 사용자가 제품 핏에 만족한다는 가정 하에 리뷰를 작성하세요.
+2. **주의:** S, M, L 같은 **구체적인 사이즈(옵션명)는 절대 언급하지 마세요.** 오직 '핏감(Fit)'과 '착용감'에 대해서만 이야기하세요.
+3. 리뷰는 구매한 상품 정보에 기반하여 작성하세요.
+4. 말투는 자연스러운 한국어 구어체(리뷰톤)를 사용하며 3줄 이내로 작성하세요.
+""")
+
+    hyde_txt = llm.invoke(hyde_prompt.format(
+        h=user_info.get('height',''), w=user_info.get('weight',''),
+        g=user_info['gender'], p=user_info.get('p',''),
+        p_info=label, cat=cat)).content
+    hyde_vec = review_emb_func.embed_query(hyde_txt)
+    print(hyde_txt)
+
+    product_score_map = {str(target_id): 1.0} # 상품 유사도 저장 (해당 추천 상품은 유사도 1)
+
+    search_pool_ids = [str(target_id)]
+    method_log = f"해당 추천 상품"
+
+    sim_ids_2 = get_sim_products(target_id, cat, brand_label=bl, limit=5)
+    if sim_ids_2:
+        product_score_map.update(sim_ids_2)
+        search_pool_ids.extend(sim_ids_2.keys())
+        method_log += f" + 같은 브랜드 그룹 내 유사도 높은 상품 {len(sim_ids_2)}개"
+
+    if len(search_pool_ids) < 3:
+        sim_ids_3 = get_sim_products(target_id, cat, brand_label=None, limit=5)
+
+        # 중복 제거
+        for id, score in sim_ids_3.items():
+            if id not in product_score_map:
+                product_score_map[id] = score
+                search_pool_ids.extend(sim_ids_2.keys())
+        method_log = f" + 같은 카테고리 내 유사도 높은 상품 {len(sim_ids_3)}개"
+
+    gender = user_info.get('gender', 'male')
+    height = int(user_info.get('height'))
+    weight = int(user_info.get('weight'))
+
+    min_h, max_h = height - 3, height + 3
+    min_w, max_w = weight - 3, weight + 3
+
+    final_docs_raw = review_db.similarity_search_by_vector(
+        hyde_vec,
+        k=30,
+        filter={
+            "$and": [
+                {"product_id": {"$in": search_pool_ids}}, # 리뷰 데이터 primary_id vectorDB 저장 시 float --> int로 타입 변환 후 str 씌우기!!!!!!!!
+                {"gender": {"$eq": gender}},
+                {"height": {"$gte": min_h}},
+                {"height": {"$lte": max_h}},
+                {"weight": {"$gte": min_w}},
+                {"weight": {"$lte": max_w}}
+            ]
+        })
+
+    if not final_docs_raw:
+        relaxed_filter = {
+            "$and": [
+                {"product_id": {"$in": search_pool_ids}},
+                {"gender": {"$eq": gender}}
+            ]
+        }
+        final_docs_raw = review_db.similarity_search_by_vector(hyde_vec, k=30, filter=relaxed_filter) # 리스트 타입 반환 [doc1, doc2, doc3...]
+
+    if not final_docs_raw:
+        return "유사 리뷰 데이터 부족", method_log
+
+    print(final_docs_raw)
+    best_doc, max_score, weight_docs = None, -1e9 , []
+    size_score = defaultdict(float)
+    size_count = defaultdict(int)
+
+    valid_doc_cnt = 0
+
+    for doc in final_docs_raw:
+        meta = getattr(doc, 'metadata', {}) or {}
+        size = meta.get('size')
+        if size:
+            size_count[size] += 1
+            valid_doc_cnt += 1
+        else:
+            continue
+    if valid_doc_cnt == 0:
+        return "best_doc is not found", method_log
+
+    for doc in final_docs_raw:
+        meta = getattr(doc, 'metadata', {}) or {}
+        prod_id = meta.get('product_id')
+        size = meta.get('size')
+        #print("DOC META:", meta) # 디버깅용 코드
+        #print("prod_id:", prod_id, 'size:', size)
+
+        if not prod_id or not size:
+            continue
+
+        dis = meta.get("score", 0.0) # 상품 유사도
+        review_sim = max(0.0, 1.0 - dis)  # 리뷰 유사도
+        s_cnt = size_count[size]
+        size_ratio_score =(1 + s_cnt / valid_doc_cnt)
+
+        prod_id = str(prod_id)
+        prod_sim = float(product_score_map.get(prod_id, 0.5)) # 상품 유사
+        w_score = prod_sim * review_sim * size_ratio_score # 가중 점수에 (추천 리뷰 사이즈 개수 / 전체 사이즈 개수)까지 곱해주기
+
+        weight_docs.append({
+            "doc": doc,
+            "id": prod_id,
+            "weight": w_score,
+            "size": size
+        })
+
+        size_score[size] += w_score
+
+        if w_score > max_score:
+            max_score = w_score
+            best_doc = {
+                "product_id": prod_id,
+                "size": size
+            }
+
+    if not best_doc:
+        return "best_doc is not found", method_log
+
+    ref_p, ref_sz = best_doc['product_id'], best_doc['size']
+    ideal_spec = set_fin_size(ref_p, ref_sz) # 가장 유사한 제품 사이즈 정보 가져오기
+
+    final_sz, info = ref_sz, "(유사 제품 사이즈 추천)"
+
+    # 추천 상품 사이즈 옵션 개수 확인
+    target_r = prod_size_df[prod_size_df['primary_id'] == str(target_id)]
+    size_cnt = len(target_r)
+
+    if size_cnt == 1:
+        final_sz = target_r.iloc[0]['size_cleaned']
+        info = "(원사이즈 제품)"
+    elif ideal_spec:
+        actual_sz = find_closest_size(target_id, ideal_spec)
+        if actual_sz:
+            final_sz = actual_sz
+            info = f"(유사 제품 {ref_p} [{ref_sz}] 실측 기반 매핑)"
+
+    weight_docs.sort(key=lambda x: x['weight'], reverse=True)
+
+    evidence_txt = '\n'.join([
+        f"-[{doc['size']}] {doc['doc'].page_content[:80]}...({doc['weight']:.2f})"
+        for doc in weight_docs[:5]
+    ])
+
+    detail_log = "\n".join([
+        f"[{i+1}위] ID: {d['id']} ({d['size']}) --> {d['weight']:.2f}점"
+        for i, d in enumerate(weight_docs[:10])
+    ])
+
+    score_dist = ", ".join([
+        f"{k}: {v:.1f}" for k, v in sorted(size_score.items(), key=lambda x:x[1], reverse=True)
+    ])
+
+    # 추천 근거 생성 LLM (상세 사이즈 정보 추가)
+    prompt = "패션 상품 구매를 고려하고 있는 사용자에게 '{s}' 사이즈 추천. 근거:\n{e}\n페르소나: {p}\n(로직: {m}, {i})"
+    msg = llm.invoke(prompt.format(
+        s=final_sz, e=evidence_txt, p=user_info.get('p',''), m=method_log, i=info)).content
+
+    return final_sz, msg
+
+# 이미지 url 가져오기
+def get_img_url(id):
+    if prod_data.empty:
+        return None
+
+    try:
+        r = prod_data[prod_data['primary_id'] == str(id).strip()]
+        if not r.empty:
+            url = r.iloc[0]['thumbnail_img_url']
+            if pd.notna(url):
+                return str(url)
+    except:
+        pass
+    return None
+
+# 검색 벡터 생성
+def get_search_vector(selected_key, user_txt, img_path):
+    vector_list = [] # input_prompt 요소들의 embedding_vector 리스트
+    message_list = []
+
+    if img_path:
+        image = Image.open(img_path)
+        inputs = clip_processor(images=image, return_tensors="pt", padding=True).to(device)
+        with torch.no_grad():
+            img_vec = clip_model.get_image_features(**inputs).cpu().numpy().tolist()[0]
+        vector_list.append(img_vec)
+        message_list.append("이미지 기반 검색")
+
+    if user_txt:
+        inputs = clip_processor(text=[user_txt], return_tensors="pt", padding=True).to(device)
+        with torch.no_grad():
+            txt_vec = clip_model.get_text_features(**inputs).cpu().numpy().tolist()[0]
+        vector_list.append(txt_vec)
+        message_list.append(f"{user_txt}에 대한 검색 중...")
+
+    if selected_key and selected_key != '선택 안 함':
+        items = style_collection.get(include=["metadatas", "embeddings"])
+        query_vec = None
+
+        for m, e in zip(items["metadatas"], items["embeddings"]):
+            if m.get("display_name") == selected_key:
+                vector_list.append(e)
+                message_list.append(f"{selected_key}에 대한 검색 중...")
+                break
+
+    if not vector_list:
+        return None, "검색 조건을 입력하세요"
+    else:
+      mean_vector = torch.mean(torch.tensor(vector_list), dim=0).tolist() # 멀티모달 사용 시 벡터 concat 후 512차원으로 projection
+      return mean_vector, ", ".join(message_list)
+
+def on_gallery_click(p_map, evt: gr.SelectData):
+    """
+    갤러리 클릭 시 해당 인덱스의 제품 라벨(Key)을 찾아 반환하는 함수
+    """
+    if not p_map:
+        return ""
+
+    keys_list = list(p_map.keys())
+
+    if evt.index < len(keys_list):
+        selected_label = keys_list[evt.index]
+        return selected_label # 텍스트 박스에 들어갈 라벨 반환
+
+    return ""
+
+# 브랜드 label 선택 시 category range 변경
+def update_cat(brand_label):
+    if not brand_label:
+        return gr.Dropdown(choices=[], value=None)
+
+    try:
+        filtered_df = prod_data[prod_data['brand_label'] == brand_label]
+        new_choices = sorted(filtered_df['category_final'].dropna().unique().tolist())
+
+        new_value = new_choices[0] if new_choices else None
+        return gr.Dropdown(choices=new_choices, value=new_value, label="카테고리 (서브)")
+
+    except Exception as e:
+        print(f" 카테고리 업데이트 실패: {e}")
+        return gr.Dropdown(choices=[], value=None)
+
+# 카테고리 선택 시 가격 range 변경 함수
+def update_price(brand_label, cat):
+    min_price = int(prod_data['sale_price'].dropna().min())
+    max_price = int(prod_data['sale_price'].dropna().max())
+
+    if not brand_label or not cat:
+        return (f"가격범위: {min_price:,}원 ~ {max_price:,}원",
+                min_price, max_price,
+                gr.update(visible=False)
+        )
+
+    try:
+        selected_prod_df = prod_data[(prod_data['brand_label'] == brand_label) & (prod_data['category_final'] == cat)]
+        update_min_price = int(selected_prod_df['sale_price'].min())
+        update_max_price = int(selected_prod_df['sale_price'].max())
+
+        price_text_info = f"가격범위: {update_min_price:,}원 ~ {update_max_price:,}원"
+
+        return price_text_info, update_min_price, update_max_price, gr.update(visible=False)
+
+    except Exception as e:
+        print(f"가격 업데이트 실패: {e}")
+        return min_price, max_price
+
+brand_description = {
+    "미니멀리즘, 높은 퀄리티, 편안함, 타임리스, 웨어러블":
+    "미니멀하고 타임리스한 디자인을 통해 높은 품질의 편안한 의류를 제공하며, 실용성과 웨어러블함을 중요시합니다.",
+    "편안함, 스타일, 개성, 실용성, 자유로움":
+    "이 클러스터의 브랜드들은 편안한 실루엣과 실용적인 디자인을 통해 개인의 개성을 표현하며, 일상에서 자유로운 스타일을 추구합니다.",
+    "편안함, 일상, 유연함, 트렌디, 개인성":
+    "일상 속에서 편안하게 착용할 수 있는 트렌디한 디자인을 추구하며, 개인의 개성과 다양한 라이프스타일을 반영하는 브랜드들이 모여 있습니다.",
+    "편안함, 유니크함, 지속 가능성, 반항적 디자인, 일상성과 특별함":
+    "이 클러스터의 브랜드들은 일상 속에서 편안함과 유니크함을 추구하며, 반항적이고 독창적인 디자인으로 새로운 흐름을 제안하는 동시에 지속 가능한 삶을 지향합니다.",
+    "편안함, 개성, 자연스러움, 균형, 다채로움":
+    "이 클러스터의 브랜드들은 편안함과 개성을 중시하며, 자연스러운 스타일과 균형 잡힌 라이프스타일을 통해 다양성을 존중하는 독창적인 패션을 제안합니다.",
+    "아웃도어, 기능성, 일상, 스포츠, 혁신":
+    "스포츠와 아웃도어 활동을 일상 속에서 즐길 수 있도록 기능성과 스타일을 겸비한 다양한 제품을 제공하는 브랜드들이 모인 클러스터입니다.",
+    "여성, 클래식, 트렌디, 웨어러블, 심플, 감성":
+    "이 클러스터의 브랜드들은 클래식함과 트렌디함을 조화롭게 담아내며, 편안한 착용감을 제공하는 웨어러블한 디자인과 감성적인 스타일을 강조합니다."
+
+    }
+def load_stye_collection():
+    data = style_collection.get(include=["metadatas"], limit=9999)
+
+    desc_dict = {}
+    for meta in data['metadatas']:
+        style_key = meta.get('display_name')
+        style_desc = meta.get('description')
+
+        if style_key and style_desc and style_key not in desc_dict:
+            desc_dict[style_key] = style_desc
+
+    return desc_dict
+
+style_description = load_stye_collection()
+
+brand_label_choice, subcat_choice = [], []
+min_price, max_price = 0, 100
+
+if not prod_data.empty:
+    brand_label_choice = sorted(prod_data['brand_label'].dropna().unique().tolist())
+    subcat_choice = sorted(prod_data['category_final'].dropna().unique().tolist())
+    min_price = int(prod_data['sale_price'].dropna().min())
+    max_price = int(prod_data['sale_price'].dropna().max())
+
+# 데이터에 맞는 변수명으로 변경 작업
+def get_brand_desc(brand_label):
+    return brand_description.get(brand_label, "")
+
+def get_style_desc(style):
+    return style_description.get(style, "")
+
+# [1] 텍스트를 예쁜 HTML 박스로 감싸주는 함수
+def format_info_box(text):
+    if not text:
+        return ""
+    # 여기에 style을 직접 적으면 절대 무시당하지 않습니다.
+    return f"""
+    <div style="
+        background-color: #f0f9ff;
+        color: #333333;
+        border: 1px solid #bae6fd;
+        border-radius: 8px;
+        padding: 12px;
+        text-align: center;
+        font-weight: 600;
+        font-size: 0.95em;
+        margin-top: 5px;
+    ">
+        {text}
+    </div>
+    """
+
+with gr.Blocks(theme=gr.themes.Soft()) as app:
+    state_pmap = gr.State({})     # 제품 메타데이터 저장
+    state_results = gr.State({})
+
+    with gr.Group(visible=True) as page_input:
+        gr.Markdown("### 1. 스타일 조건을 입력해주세요")
+        with gr.Column():
+          in_g = gr.Radio(["male", "female"], value="male", label="성별")
+          check = gr.Checkbox(label="다른 성별의 제품도 볼래요", value=False)
+
+        with gr.Row():
+          in_h, in_w = gr.Number(175, label="키"), gr.Number(70, label="몸무게")
+
+        with gr.Row():
+          with gr.Column():
+              in_bg = gr.Dropdown(brand_label_choice, value=brand_label_choice[0] if brand_label_choice else None,
+                                  label="브랜드 그룹", info="선택 시 브랜드 설명이 아래에 나타납니다.")
+              initial_bg_text = get_brand_desc(brand_label_choice[0] if brand_label_choice else "")
+              bg_desc = gr.HTML(value=format_info_box(initial_bg_text), visible=True)
+
+        in_cat = gr.Dropdown(subcat_choice, value=subcat_choice[0] if subcat_choice else None, label="카테고리")
+
+        price_info = gr.Markdown(value=f"가격범위: {min_price:,}원 ~ {max_price:,}원")
+        with gr.Row():
+          min_num = gr.Number(value=min_price, label="최소 가격 입력")
+          max_num = gr.Number(value=max_price, label="최대 가격 입력")
+        price_error = gr.Markdown("", visible=False)
+
+        with gr.Column():
+            in_sel = gr.Dropdown(choices = style_key_options, value="선택 안 함",
+                                 label="스타일", info="원하는 스타일 무드를 선택해보세요.")
+            style_desc = gr.HTML(value=format_info_box(""), visible=True)
+
+        in_txt = gr.Textbox(label="텍스트 (패션 추구미를 직접 입력해보세요)")
+        in_img = gr.Image(type="filepath", label="이미지를 넣으면 더 정밀한 추천을 받을 수 있어요 (선택 사항)")
+
+        btn_s = gr.Button("🔍 검색", variant='primary', size='lg')
+
+        # 검색 결과 페이지
+    with gr.Group(visible=False) as page_result:
+        gr.Markdown("### 2. 추천 결과")
+        out_p = gr.Textbox(label="나만의 패션 페르소나", lines=3)
+
+        with gr.Row():
+          with gr.Column(scale=1):
+              gal = gr.Gallery(label="검색 결과", columns=3)
+
+          with gr.Column(scale=2):
+              sel = gr.Textbox(label="사이즈 추천을 원하는 상품")
+              btn_r = gr.Button("사이즈 추천")
+              f_sz = gr.Textbox(label="추천 사이즈", lines=1)
+              out_m = gr.Textbox(label="추천 이유 설명", lines=5, max_lines=10)
+
+        with gr.Row():
+            btn_back = gr.Button("검색 조건 다시 입력하기", variant='secondary')
+
+    def validate_price(min_num, max_num):
+        if min_num < min_price:
+            return gr.update(value=f"최소 가격은 {min_price:,}원 이상이어야 합니다.", visible=True)
+        if max_num > max_price:
+            return gr.update(value=f"최대 가격은 {max_price:,}원 이하이어야 합니다.", visible=True)
+        if min_num > max_num:
+            return gr.update(value="최소 가격이 최대 가격보다 클 수 없습니다.", visible=True)
+
+        return gr.update(value="", visible=False)
+
+    min_num.change(fn=validate_price, inputs=[min_num, max_num], outputs=[price_error])
+    max_num.change(fn=validate_price, inputs=[min_num, max_num], outputs=[price_error])
+
+    in_bg.change(fn=lambda x: format_info_box(get_brand_desc(x)),
+                 inputs=[in_bg],
+                 outputs=[bg_desc])
+    in_sel.change(fn=lambda x: format_info_box(get_style_desc(x)),
+                  inputs=[in_sel],
+                  outputs=[style_desc])
+
+    in_bg.change(fn=update_cat, inputs=[in_bg], outputs=[in_cat])
+    in_cat.change(fn=update_price, inputs=[in_bg, in_cat], outputs=[price_info, min_num, max_num, price_error])
+
+    # 페이지 전환 함수
+    def move_to_result():
+        return gr.update(visible=False), gr.update(visible=True)
+
+    def move_to_input():
+        return gr.update(visible=True), gr.update(visible=False)
+
+    def search_and_log(bg, c, sl, tx, im, g, h, w, min_p, max_p, check):
+        try:
+          gr.Info("🚀 사용자 데이터 분석을 시작합니다...")
+
+          if not bg or not c:
+              raise gr.Error("브랜드그룹과 카테고리를 반드시 선택하세요")
+
+          # 1. 기존 검색 로직 수행
+          user_info = {'gender': g, 'height': h, 'weight': w}
+
+          results = search_recom_products(bg, c, sl, tx, im, user_info, min_p, max_p, check)
+
+          gr.Info("✅ 분석 완료! 결과 페이지로 이동합니다.")
+          persona_result = results[1]
+
+          try:
+            # 2. DB에 입력값과 결과 저장
+            log_search_to_sheet(bg, c, min_p, max_p, sl, tx, check, persona_result)
+          except Exception as log_e:
+            print(f"로그 저장 실패: {log_e}")
+
+          return results
+
+        except gr.Error as ge:
+          raise ge
+
+        except Exception as e:
+          print(f"시스템 에러: {e}")
+          raise gr.Error(f"시스템 오류가 발생했습니다: {str(e)}")
+
+    def size_recom_and_log(sel_product, p_map, u_info):
+        # 1. 기존 사이즈 추천 로직 수행
+        # recom_size 함수는 2개의 값을 반환한다고 가정 (f_sz, out_m)
+        rec_size, reason = recom_size(sel_product, p_map, u_info)
+
+        # 2. DB에 저장
+        log_size_to_sheet(sel_product, u_info, rec_size, reason)
+
+        return rec_size, reason
+
+    # 1. 검색 버튼 연결
+    btn_s.click(
+        fn=search_and_log,
+        inputs=[in_bg,in_cat,in_sel,in_txt,in_img,in_g,in_h,in_w, min_num, max_num, check],
+        outputs=[gal, out_p, state_pmap, state_results]
+    ).then(
+        fn=move_to_result,
+        inputs=None,
+        outputs=[page_input, page_result]
+    ) # 버튼 클릭 시 페이지 이동
+
+    btn_back.click( # 버튼 클릭 시 페이지 이동
+        fn=move_to_input,
+        inputs=None,
+        outputs=[page_input, page_result]
+    )
+
+    gal.select(fn=on_gallery_click, inputs=[state_pmap], outputs=sel)
+
+    # 3. 사이즈 추천 버튼 연결
+    # inputs에 state_persona를 넣어서 recommend_size로 전달
+    btn_r.click(
+        fn=size_recom_and_log,
+        inputs=[sel, state_pmap, state_results], # -> state_persona 값을 꺼내서 씀
+        outputs=[f_sz, out_m]
+    )
+
+try:
+    app.close()
+except:
+    pass
+
+app.queue().launch(share=True)

fashion_key.json

@@ -0,0 +1,13 @@
+{
+  "type": "service_account",
+  "project_id": "fluent-music-480402-m3",
+  "private_key_id": "204a19a89bde0b461b35ddd5149b6d34e0e955c6",
+  "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDuBlEcoMBWT62A\nPX7cX6e/vYYF2Z3F/Bh+TmM5B8l3yHUU/fAiDwV2abb/TYAPPcUXu/ElVwkL8GBl\n9uBRV6zc3GsndR9Vu7PQ1j4pt4BKSNhwQPWcmxHhiqET52G5+EDET0SyXD6xjgq8\nAbMFuzkqbtIMUDIo27MND0I47bCerxSCjIyBSKe7faJ69WX7z+xGoZXyuND5Ln4D\n2jyt+vCV9nrX1MkaHMkN9SfwvSh/SlZT7VkbekgjtGK2lQW8VR9QpqcZAGxq/BVt\n7CUghQdB/0efO5DQqgYzPIYiBoSxazH7t13igDZcNeSODcDOxPmAsSRnjK1gtH8n\nB/01HZETAgMBAAECggEAAR0ywElnJCrxrEd3eq/VQt5Vxnlh55anu7rd5fLOa0Kp\nTJcJ5vyJYe89xUlR3wLC7Z5TNFI0Cgs6pLhrdWVp9AHxbr707JbDzHgidcG/X+V8\nRr3IR1Nw/4oP04j8TOz5WO0hm+wadT0aqRdZ1XN6XMvQbyA+5Cb0RzclzvDsFSYx\nSMEICHJ4+q6gi4y42J6b7uw/9kPHhNuVJjBZ9aVDChdLqHvRfIRFxOS/15FlfMyL\n+10gu3iWX1jK975+/wBOQ2fe6RcZ+uLiE0hQ4HGzSZTQLtaf++Vx7K/l0+qMdOMJ\n6sVkuNe40BEij7MOV/2zzC7dQFAIAmyfTsPAEUyBkQKBgQD9wfSrg6rDokdnlJee\nq3p/MVb7DA21G6BEGaq64NN7RWOh98fT+gfHFKI3B7qCGWiSU3Boa5xAylplDHv/\n1ZbKYN8Oj0EA1XHSwYwVMBVfcpDKaCr1kCfvLcvNRQxoQMVc9LIZxPQymGhBn9U3\n1ZTyzfO6l12TDpjq8I2vafy9hwKBgQDwIMU3ewAL77/es3svGqId+OLvWf6fsS0Z\nlnbZGExJxs34xgc7sUDJHV2UGX7FVKrF/jOqBUDTSfmI/kAn85ETF0uBO7hIeuqz\nuqNwDfAIugT45nTPzCS0Xl0BGf0zOnsvUibjC462mm1KM4g/dcep4I2aeR7yMJFy\nmW94gGcTFQKBgDL4fpjk/awGMKmRo1Lvxs89recHaMl0HyEOtsiK2G/uZDDogG8H\nzgAjGOJM3x261NJviCixVNV+z+F0PIQK9xr3klZuV/Q+63oV/nlTCzf83zCI8/gX\nWK4mWMWGlRNrzzj4vb2HXjW7f1WPMVjhweVzkP1t4hHj4LtwTkVp2KaJAoGASp4U\nSqo5GHx2xfBF7hw7lk65ziDMA7mdxx6/bbSkOCTD6nM22jC5bgVnB9doUk9+Bap5\nSXL6cu3A0fYX35JLWYBaoRz6peM0PYdYtEBQf5W2Z9XNJKlOGpJcGjSGPr4Ee27u\n0IzN2yZfobgjtXyW/83ckszideXrvI27WtmjrgUCgYEAiyg/gtAki5HAWG1bsa9p\ndB4yXdW9a7izkWL3QHCodkpF9syQzvvZDK4aP28T4mF0/SxS0aZEj8ZXo7S2en41\nvAvk+iC3qObkQelJzLbLb5imLxoA9n9nHUjQG6ENJtym7eUwrsHjW+a8RKatmR2x\n36GyilDuARXOVLi6zE6x9vA=\n-----END PRIVATE KEY-----\n",
+  "client_email": "fashion-recom@fluent-music-480402-m3.iam.gserviceaccount.com",
+  "client_id": "107965914755558240659",
+  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+  "token_uri": "https://oauth2.googleapis.com/token",
+  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/fashion-recom%40fluent-music-480402-m3.iam.gserviceaccount.com",
+  "universe_domain": "googleapis.com"
+}

final_prod_data.csv

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

final_review_df.csv

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

prod_emb_data.pkl

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

requirements.txt

@@ -0,0 +1,16 @@
+gradio
+pandas
+numpy
+torch
+chromadb
+pysqlite3-binary 
+transformers
+langchain
+langchain-community
+langchain-huggingface
+langchain-openai
+openai
+sentence-transformers
+gspread
+oauth2client
+pillow

style_key_data.csv

@@ -0,0 +1,49 @@
+style_key,display_name,synonyms,description,embedding_queries_en,embedding_queries_ko
+clean_girl_aesthetic,클린걸 에스테틱,"['clean girl aesthetic', '클린걸룩', '클린룩', '꾸안꾸 미니멀']","깔끔하고 미니멀하며 자연스러운 아름다움을 강조하는 스타일. 뉴트럴 톤, 심플한 실루엣, 정돈된 헤어와 메이크업이 특징. (예: 화이트 티셔츠 + 스트레이트 데님 + 골드 주얼리)","['clean girl aesthetic', 'minimalist natural look', 'effortless chic fashion', 'neutral tones outfit', 'simple silhouette style']","['클린걸 에스테틱', '꾸안꾸 미니멀룩', '자연스러운 스타일', '뉴트럴톤 코디', '심플한 실루엣']"
+vanilla_girl_aesthetic,바닐라걸 에스테틱,"['vanilla girl aesthetic', '바닐라걸룩', '소프트걸', '크림룩']","부드럽고 포근한 느낌을 주는 스타일. 크림, 베이지, 화이트 등 밝고 따뜻한 색감과 니트, 코튼 등 부드러운 소재를 주로 사용. (예: 아이보리 니트 스웨터 + 새틴 스커트)","['vanilla girl aesthetic', 'soft cozy fashion style', 'cream and beige outfits', 'light academia soft', 'warm and comfortable look']","['바닐라걸 에스테틱', '부드럽고 포근한 룩', '크림색 베이지색 코디', '소프트걸 스타일', '따뜻한 느낌의 패션']"
+dark_romantic,다크 로맨틱,"['dark romanticism', 'gothic romantic', '다크 로맨틱룩']","로맨틱한 실루엣에 어둡고 고딕적인 요소를 결합한 스타일. 레이스, 프릴, 코르셋 디테일과 블랙, 버건디 등 깊은 색상을 사용. (예: 블랙 레이스 드레스 + 벨벳 초커)","['dark romantic fashion', 'gothic romantic style', 'victorian goth look', 'lace and velvet dark aesthetic', 'moody romantic outfit']","['다크 로맨틱 패션', '고딕 로맨틱 스타일', '빅토리안 고스룩', '레이스 벨벳 어두운 코디', '분위기 있는 로맨틱룩']"
+indie_sleaze,인디 슬리즈,"['indie sleaze aesthetic', '2000s indie', '인디 슬리즈룩']","2000년대 후반~2010년대 초반 인디 씬의 자유분방하고 다소 정돈되지 않은 스타일. 빈티지, 그런지, 일렉트로 팝 문화를 혼합. (예: 찢어진 스키니진 + 밴드 티셔츠 + 가죽 재킷)","['indie sleaze fashion', '2000s indie aesthetic', 'grunge party look', 'messy chic style', 'vintage band shirt outfit']","['인디 슬리즈 패션', '2000년대 인디 스타일', '그런지 파티룩', '자유분방한 빈티지', '밴드 티셔츠 코디']"
+genderless,젠더리스,"['genderless fashion', 'unisex fashion', '젠더리스룩', '유니섹스']","성별의 경계를 허무는 스타일. 남성복과 여성복의 구분이 없는 오버사이즈 핏, 중성적인 디자인의 아이템을 활용. (예: 오버사이즈 셔츠 + 와이드 슬랙스)","['genderless fashion style', 'unisex clothing', 'androgynous look', 'breaking gender norms in fashion', 'oversized neutral outfit']","['젠더리스 패션', '유니섹스 의류', '중성적인 룩', '성별 구분 없는 스타일', '오버사이즈 중성적인 코디']"
+deconstructed_fashion,해체주의 패션,"['deconstructed clothing', 'deconstructionism', '해체주의룩']","의복의 기존 구조를 의도적으로 해체하고 재조립하여 새로운 형태를 만드는 아방가르드한 스타일. 비대칭, 노출된 시접, 미완성된 듯한 디테일이 특징. (예: 비대칭 헴라인 스커트 + 재구성된 셔츠)","['deconstructed fashion', 'deconstructionism in clothing', 'asymmetrical garment design', 'raw edges unfinished look', 'avant-garde reconstruction']","['해체주의 패션', '의류 해체주의', '비대칭 디자인', '노출된 시접 마감', '아방가르드 재구성']"
+avant_garde,아방가르드,"['avant-garde fashion', 'experimental fashion', '전위적인 패션']","전통적인 패션의 관습과 규범을 깨는 실험적이고 혁신적인 스타일. 비정형적인 실루엣, 독특한 소재, 예술적인 표현을 중시. (예: 과장된 볼륨의 구조적인 드레스)","['avant-garde fashion style', 'experimental clothing', 'unconventional silhouettes', 'artistic fashion', 'pushing fashion boundaries']","['아방가르드 패션', '실험적인 의상', '비정형적 실루엣', '예술적인 패션', '관습을 깨는 디자인']"
+futuristic_fashion,퓨처리스틱,"['futuristic style', 'sci-fi fashion', '미래지향적 패션', '사이버펑크']","미래나 과학 소설(SF)에서 영감을 받은 스타일. 메탈릭 소재, 기하학적 패턴, 구조적인 실루엣, 테크웨어 요소를 특징으로 함. (예: 실버 메탈릭 패딩 점퍼 + 테크 팬츠)","['futuristic fashion', 'sci-fi inspired clothing', 'metallic outfits', 'cyberpunk style', 'techwear aesthetic']","['퓨처리스틱 패션', 'SF 영화 패션', '메탈릭 소재 코디', '사이버펑크 스타일', '테크웨어']"
+goth,고스,"['goth style', 'gothic fashion', '고스룩', '고딕']","어둡고 신비로우며 종종 으스스한 분위기를 연���하는 스타일. 주로 블랙 컬러를 사용하며, 레이스, 가죽, 벨벳 소재와 코르셋, 플랫폼 부츠 등을 활용. (예: 올블랙 코디 + 가죽 부츠 + 실버 액세서리)","['goth fashion style', 'all black gothic look', 'dark aesthetic clothing', 'lace and leather goth', 'platform boots outfit']","['고스 패션 스타일', '올블랙 고딕룩', '어두운 패션', '레이스 가죽 고스', '플랫폼 부츠 코디']"
+emo,이모,"['emo style', 'emo fashion', '이모룩', '이모코어']","이모(Emo) 펑크 음악 하위문화에서 파생된 스타일. 감정적인 표현을 중시하며, 스키니 진, 밴드 티셔츠, 스터드 벨트, 짙은 아이라이너가 특징. (예: 블랙 밴드 티셔츠 + 블랙 스키니진 + 컨버스)","['emo fashion style', 'emotional hardcore fashion', 'skinny jeans and band shirt', 'studded belt aesthetic', '2000s emo look']","['이모 패션 스타일', '이모코어 패션', '스키니진 밴드 티셔츠', '스터드 벨트', '2000년대 이모룩']"
+mod_style,모드,"['mod fashion', '1960s mod', '모드룩', '60년대 스타일']","1960년대 영국 런던에서 시작된 모던(Modern) 스타일. 깔끔하고 대담한 실루엣, 기하학적 패턴, 미니 스커트, A라인 드레스가 특징. (예: A라인 미니 드레스 + 앵클 부츠)","['mod fashion style', '1960s London look', 'A-line mini dress', 'geometric patterns clothing', 'Twiggy style']","['모드 패션 스타일', '1960년대 런던 패션', 'A라인 미니 드레스', '기하학적 패턴', '트위기 스타일']"
+gorpcore,고프코어,"['gorpcore', '고프코어룩', '아웃도어룩', '바람막이 코디']","아웃도어 활동을 위한 기능성 의류(바람막이, 등산화, 카고 팬츠)를 일상복으로 활용하는 스타일. 'Gorp'는 등산객이 먹는 견과류 믹스를 의미.","['gorpcore aesthetic', 'outdoor functional wear as daily fashion', 'man wearing a windbreaker and cargo pants', 'hiking boots street style', 'arcteryx style jacket']","['고프코어 스타일', '기능성 아웃도어 데일리룩', '바람막이와 카고 팬츠 코디', '등산화 스트릿 패션', '아크테릭스 스타일 자켓']"
+balletcore,발레코어,"['balletcore', '발레코어룩', '발레리나 스타일', '리본 패션']","발레리나의 연습복에서 영감을 받은 스타일. 발레 플랫 슈즈, 레그 워머, 튤 스커트(샤 스커트), 리본, 랩 가디건 등이 핵심 아이템.","['balletcore aesthetic', 'ballerina inspired fashion', 'wearing ballet flats and leg warmers', 'tulle skirt with wrap cardigan', 'outfit with pink ribbons']","['발레코어 스타일', '발레리나 패션', '발레 플랫 슈즈와 레그 워머 코디', '튤 스커트와 랩 가디건', '핑크 리본 디테일 아웃핏']"
+blokecore,블록코어,"['blokecore', '블록코어룩', '축구 유니폼 코디', '사커 저지']","영국 남성(Bloke)들이 축구 유니폼(저지)을 일상복처럼 입는 스타일. 축구 유니폼 상의에 데님 팬츠나 트랙 팬츠, 스니커즈(주로 아디다스 삼바)를 매치.","['blokecore aesthetic', 'soccer jersey street style', 'wearing football shirt with jeans', 'adidas samba sneakers outfit', 'sports jersey fashion']","['블록코어 스타일', '축구 유니폼 스트릿 패션', '사커 저지와 청바지 코디', '아디다스 삼바 스니커즈 매치', '스포츠 저지 패션']"
+girlcore,걸코어,"['girlcore', '걸코어룩', '걸리시룩', '하이틴 스타일']","소녀스러운 감성을 극대화한 스타일. 핑크 컬러, 리본, 레이스, 프릴, 크롭탑, 미니 스커트 등을 활용하여 귀엽고 발랄한 무드를 연출.","['girlcore aesthetic', 'girly fashion style', 'pink ribbon and lace details', 'cute crop top and mini skirt', 'k-pop idol style outfit']","['걸코어 스타일', '소녀 감성 패션', '핑크 리본과 레이스 디테일', '귀여운 크롭탑과 미니 스커트', '하이틴 영화 스타일']"
+y2k,Y2K,"['Y2K fashion', 'Y2K 스타일', '2000년대 패션', '세기말 패션']","2000년대 초반(Year 2000) 유행했던 스타일. 로우라이즈 팬츠, 크롭탑, 벨벳 트레이닝 수트, 카고 팬츠, 화려한 그래픽과 컬러가 특징.","['Y2K fashion aesthetic', 'early 2000s style', 'low-rise jeans and crop top', 'velour tracksuit outfit', 'colorful graphic t-shirt']","['Y2K 패션', '2000년대 초반 스타일', '로우라이즈 팬츠와 크롭탑 코디', '벨벳 트레이닝 수트', '화려한 그래픽 티셔츠']"
+copenhagen_core,코펜하겐 코어,"['copenhagen core', '코펜하겐 스타일', '덴마크 패션', '스칸디나비아 스타일']","덴마크 코펜하겐 여성들의 편안하면서도 컬러풀하고 실용적인 스트릿 스타일. 비비드한 컬러의 니트, 와이드 데님, 편안한 스니커즈 등이 특징.","['copenhagen street style', 'scandinavian fashion', 'colorful knit vest and wide-leg denim', 'vibrant color patterns', 'practical layered look with sneakers']","['코펜하겐 스트릿 스타일', '���칸디나비아 패션', '컬러풀한 니트 조끼와 와이드 데님', '생동감 있는 컬러 패턴', '스니커즈를 매치한 실용적인 레이어드 룩']"
+old_money_look,올드머니룩,"['old money aesthetic', 'quiet luxury', '올드머니', '조용한 럭셔리']","과시하지 않는 상류층의 클래식하고 고급스러운 스타일. 로고 플레이를 배제하고, 린넨, 캐시미어 등 고급 소재와 뉴트럴 톤(베이지, 화이트, 네이비)을 주로 사용.","['quiet luxury aesthetic', 'old money style', 'linen shirt and beige slacks', 'minimalist luxury fashion without logos', 'classic preppy style with cashmere sweater']","['조용한 럭셔리 패션', '로고 없는 고급스러운 스타일', '린넨 셔츠와 베이지색 슬랙스 코디', '캐시미어 스웨터를 활용한 클래식 룩', '뉴트럴 톤의 우아한 아웃핏']"
+running_core,러닝코어,"['running core', '러닝코어룩', '러닝화 코디', '스포츠웨어 믹스']","러닝(달리기)을 위한 기능성 의류를 일상복과 결합한 스타일. 고프코어와 유사하나, 러닝화, 바람막이, 레깅스, 스포츠 쇼츠 등 '러닝'에 더 집중.","['running core aesthetic', 'fashion with running shoes', 'windbreaker jacket and shorts', 'sportswear as daily outfit', 'technical running apparel']","['러닝코어 스타일', '러닝화 패션 코디', '바람막이 자켓과 쇼츠', '스포츠웨어 데일리룩', '기능성 러닝 의류']"
+rock_chic,락시크,"['rock chic', '락시크룩', '락스타일', '글램락']","락(Rock) 음악 문화에서 영감을 받은 시크한 스타일. 가죽 재킷, 스키니진(주로 블랙), 밴드 티셔츠, 워커 부츠가 핵심 아이템.","['rock chic style', 'leather jacket and skinny jeans', 'band t-shirt with biker jacket', 'dark aesthetic with boots', 'glam rock fashion']","['락시크 스타일', '가죽 자켓과 스키니진', '밴드 티셔츠와 바이커 자켓', '부츠를 활용한 다크한 패션', '글램락 무드']"
+grunge,그런지룩,"['grunge', '그런지', '너바나 스타일', 'nirvana style']","1990년대 락 밴드 '너바나'에서 유래한, 지저분하고 낡아 보이는 스타일. 찢어진 데님, 체크무늬 플란넬 셔츠, 빈티지 티셔츠, 워커 등을 레이어드.","['90s grunge aesthetic', 'kurt cobain style fashion', 'ripped jeans with flannel check shirt', 'vintage band t-shirt and worn-out boots', 'layered messy look']","['90년대 그런지 스타일', '커트 코베인 패션', '찢어진 청바지와 체크 플란넬 셔츠', '빈티지 밴드 티셔츠와 낡은 부츠', '지저분하게 레이어드한 룩']"
+punk,펑크룩,"['punk', '펑크 스타일', '펑크 패션']","1970년대 펑크 락 문화에 기반한 반항적인 스타일. 스터드(징) 박힌 가죽 재킷, 찢어진 옷, 타탄 체크(플래드) 팬츠, 안전핀, 닥터마틴 워커가 상징적.","['punk fashion aesthetic', 'studded leather jacket', 'tartan plaid pants', 'ripped t-shirt with safety pins', 'dr. martens boots style']","['펑크 패션 스타일', '스터드 가죽 자켓', '타탄 체크 바지', '안전핀으로 고정한 찢어진 티셔츠', '닥터마틴 워커 코디']"
+boho_chic,보호 시크,"['boho chic', '보호 시크룩', '페스티벌룩']","보헤미안(Bohemian) 스타일을 현대적이고 시크하게 재해석한 룩. 주로 페스티벌 룩으로 인기. 프린지(술 장식), 스웨이드, 로브 가디건, 에스닉 패턴이 특징.","['boho chic style', 'modern bohemian fashion', 'music festival outfit', 'suede jacket with fringe', 'ethnic pattern dress']","['보호 시크 스타일', '현대적인 보헤미안 패션', '뮤직 페스티벌 코디', '프린지 디테일의 스웨이드 자켓', '에스닉 패턴 원피스']"
+bohemian,보헤미안,"['bohemian style', '보헤미안룩', '집시 스타일']","사회 관습에 얽매이지 않는 집시(Gypsy)들의 자유로운 스타일. 에스닉하고 이국적인 패턴, 루즈핏의 맥시 드레스, 자수, 천연 소재가 특징.","['bohemian aesthetic', 'gypsy style fashion', 'ethnic print maxi dress', 'loose fit natural fabric', 'embroidered tunic']","['보헤미안 스타일', '집시 패션', '에스닉 프린트 맥시 원피스', '루즈핏 천연 소재 의류', '자수가 놓인 튜닉']"
+hippie_chic,히피 시크,"['hippie chic', '히피룩', '70년대 스타일']","1970년대 '히피' 문화에서 영감을 받은 스타일. 플라워 패턴, 플레어 팬츠(나팔바지), 크로셰(코바늘 뜨개) 니트, 헤어밴드, 평화의 상징 등이 특징.","['70s hippie style', 'hippie chic fashion', 'flare pants and flower pattern shirt', 'crochet knit vest', 'peace sign accessories']","['70년대 히피 스타일', '히피 시크 패션', '나팔바지와 플라워 패턴 셔츠', '크로셰 니트 조끼', '평화 상징 액세서리']"
+new_romanticism,뉴로맨티시즘,"['new romanticism', '뉴로맨틱룩', '80년대 패션']","1980년대 초 영국 팝 문화(듀란듀란 등)에서 유래한 화려하고 젠더리스한 스타일. 프릴이나 러플이 달린 블라우스, 화려한 메이크업, 과장된 실루엣이 특징.","['80s new romantic fashion', 'duran duran style', 'frilly blouse with ruffles', 'flamboyant genderless look', 'dandy pirate aesthetic']","['80년대 뉴로맨틱 패션', '듀란듀란 스타일', '프릴과 러플이 달린 블라우스', '화려한 젠더리스 룩', '과장된 실루엣']"
+mori_girl,모리걸,"['mori girl', '모리걸룩', '숲속의 소녀']","일본에서 유래한 '숲속의 소녀'를 뜻하는 스타일. 천연 소재(린넨, 코튼), 아스톤(Earth-tone) 컬러, 레이스, 자수 등을 활용해 여러 겹 레이어드하는 것이 특징.","['japanese mori girl style', 'forest girl aesthetic', 'layered natural fabrics dress', 'earth tone clothing with lace', 'vintage inspired loose fit']","['일본 모리걸 스타일', '숲속의 소녀 패션', '천연 소재 레이어드 원피스', '아스톤과 레이스 디테일', '빈티지 감성 루즈핏']"
+natural,내추럴,"['natural style', '내추럴룩', '편안한 스타일', '린넨 코디']","자연스럽고 편안한 무드를 추구하는 스타일. 린넨, 코튼 등 천연 소재와 베이지, 아이보리, 브라운 등 뉴트럴 컬러, 루즈핏 실루엣이 중심.","['natural aesthetic fashion', 'comfortable loose fit', 'linen shirt and cotton pants', 'neutral color palette', 'simple effortless look']","['내추럴 스타일 패션', '편안한 루즈핏', '린넨 셔츠와 코튼 팬츠', '뉴트럴 컬러 코디', '꾸밈없는 편안한 룩']"
+french_chic,프렌치시크,"['french chic', '프렌치시크룩', '파리지앵 스타일']","프랑스 파리 여성들의 무심한 듯 시크한 스타일. 스트라이프 티셔츠(브레통 셔츠), 트렌치 코트, 발레리나 플랫, 레드 립 등이 상징적.","['french chic aesthetic', 'parisian style fashion', 'breton stripe shirt', 'effortless chic with trench coat', 'jeanne damas style']","['프렌치시크 스타일', '파리지앵 패션', '스트라이프 티셔츠 (브레통 셔츠)', '트렌치 코트를 활용한 무심한 시크함', '제인 버킨 스타일']"
+western_look,웨스턴룩,"['western look', '웨스턴 스타일', '카우보이 스타일']","미국 서부 카우보이 스타일에서 영감을 받은 룩. 데님(청청 패션), 웨스턴 부츠, 프린지 장식, 웨스턴 셔츠, 볼로 타이 등이 특징.","['western fashion style', 'cowboy aesthetic', 'denim on denim with cowboy boots', 'western shirt with fringe jacket', 'bolo tie accessory']","['웨스턴 패션 스타일', '카우보이 스타일', '청청 패션과 웨스턴 부츠', '웨스턴 셔츠와 프린지 자켓', '볼로 타이 액세서리']"
+minimal,미니멀,"['minimalism', '미니멀리즘', '미니멀룩']","장식적인 요소를 최소화하고 단순함을 추구하는 스타일. 깔끔한 실루엣, 무채색(블랙, 화이트, 그레이) 및 뉴트럴 톤, 로고가 없는 디자인이 특징.","['minimalist fashion', 'clean silhouette outfit', 'monotone clothing', 'simple and modern look', 'unembellished design']","['미니멀 패션', '깔끔한 실루엣의 아웃핏', '무채색 코디', '심플하고 모던한 룩', '장식 없는 디자인']"
+simple_basic,심플 베이직,"['simple basic', '심플 베이직룩', '기본템 코디']","미니멀과 유사하나, '기본 아이템'에 더 초점을 맞춘 스타일. 흰 티셔츠, 기본 셔츠, 청바지, 슬랙스 등 유행을 타지 않는 기본 아이템 위주의 조합.","['simple basic style', 'wardrobe essentials', 'white t-shirt and blue jeans', 'classic button-down shirt', 'timeless basic items']","['심플 베이직 스타일', '기본 아이템 코디', '흰 티셔츠와 청바지', '클래식 버튼다운 셔츠', '유행 안 타는 기본템']"
+modern_chic,모던시크,"['modern chic', '모던시크룩', '도시적인 스타일']","현대적이고(Modern) 세련된(Chic) 도시적인 무드의 스타일. 미니멀을 기반으로 하되, 구조적인 실루엣(블레이저, 와이드 슬랙스)이나 포인트 컬러를 사용해 세련미를 강조.","['modern chic aesthetic', 'urban sophisticated style', 'structured blazer outfit', 'wide-leg slacks', 'minimal but sharp look']","['모던시크 스타일', '도시적이고 세련된 룩', '각 잡힌 블레이저 코디', '와이드 슬랙스', '미니멀하지만 날카로운 룩']"
+modern_classic,모던 클래식,"['modern classic', '모던 클래식룩']","전통적인 클래식 아이템(트렌치 코트, 테일러드 수트, 로퍼)을 현대적인 실루엣이나 소재와 결합하여 재해석한 스타일.","['modern classic style', 'timeless fashion with modern twist', 'classic trench coat', 'tailored suit', 'loafers with slacks']","['모던 클래식 스타일', '현대적으로 재해석한 클래식 패션', '클래식 트렌치 코트', '테일러드 수트', '로퍼와 슬랙스 코디']"
+dandy,댄디,"['dandy style', '댄디룩', '깔끔한 남성복']","멋을 내는 남성(Dandy)이라는 뜻에서 유래한, 깔끔하고 클래식한 남성 스타일. 주로 테일러드 재킷, 셔츠, 슬랙스, 니트, 로퍼 등을 활용.","['dandy style for men', ""clean and neat men's fashion"", 'tailored jacket with slacks', 'knitwear over shirt', 'classic loafers']","['댄디 스타일', '깔끔한 남자 패션', '테일러드 자켓과 슬랙스', '셔츠 위 니트 레이어드', '클래식 로퍼 코디']"
+vintage,빈티지,"['vintage style', '빈티지룩', '구제 패션', '레트로']","과거 특정 시대(주로 20세기)의 패션을 재현하거나 실제 중고(구제) 의류를 활용하는 스타일. 바랜 색감, 레트로 그래픽, 고유한 패턴이 특징.","['vintage fashion aesthetic', 'retro style clothing', 'secondhand clothing look', '80s or 90s inspired outfit', 'faded colors and retro graphics']","['빈티지 패션 스타일', '레트로 스타일 의류', '구제 옷 코디', '80년대 또는 90년대 감성 룩', '빛 바랜 색감과 레트로 그래픽']"
+street_fashion,스트릿 패션,"['streetwear', '스트릿룩', '스트리트 패션']","(대분류) 스케이트보드, 힙합, 서핑 등 도시의 길거리(Street) 하위문화에서 발생한 패션. 루즈핏, 그래픽 티셔츠, 후드티, 스니커즈가 중심.","['streetwear fashion', 'urban street style', 'graphic hoodie and baggy jeans', 'sneakers culture', 'supreme style']","['스트릿웨어 패션', '도시 스트릿 스타일', '그래픽 후드와 배기진', '스니커즈 문화', '슈프림 스타일']"
+hip_hop,힙합,"['hip hop fashion', '힙합 스타일', '스웩']","힙합 문화에서 파생된 스타일. 매우 넉넉한 오버사이징(배기 팬츠, 큰 후드), 스냅백, 볼드한 액세서리(체인), 농구화 등이 특징.","['hip hop fashion style', '90s hip hop look', 'oversized hoodie and baggy pants', 'snapback cap and gold chain', 'basketball sneakers']","['힙합 패션 스타일', '90년대 힙합 룩', '오버사이즈 후드와 배기 팬츠', '스냅백과 골드 체인', '농구화 코디']"
+skater_look,스케이터룩,"['skater style', '스케이터 스타일', '보드룩']","스케이트보더들의 스타일. 활동성을 위한 루즈핏 티셔츠, 반스(Vans)나 컨버스(Converse) 같은 스케이트 슈즈, 디키즈(Dickies) 팬츠, 볼캡이 상징적.","['skater style aesthetic', 'skateboarder fashion', 'loose fit graphic t-shirt', 'vans old skool sneakers', 'dickies pants and beanie']","['스케이터 스타일', '스케이트보더 패션', '루즈핏 그래픽 티셔츠', '반스 올드스쿨 스니커즈', '디키즈 팬츠와 비니']"
+techwear,테크웨어,"['techwear', '테크웨어룩', '아크로님 스타일']","고프코어와 유사하나, 더 도시적이고 전술적(Tactical)인 무드를 가짐. 기능성 방수/방풍 소재, 많은 포켓, 스트랩, 버클 디테일, 어두운 컬러가 특징.","['techwear aesthetic', 'urban functional fashion', 'jacket with many pockets and straps', 'waterproof cargo pants', 'acronym style']","['테크웨어 스타일', '도시형 기능성 패션', '포켓과 스트랩이 많은 자켓', '방수 카고 팬츠', '아크로님 스타일']"
+workwear,워크웨어,"['workwear', '워크웨어룩', '아메카지 기반']","19-20세기 미국 노동자들의 작업복에서 유래한 스타일. 튼튼한 데님(진), 덕 캔버스 소재(칼하트), 워커 부츠, 오버롤(멜빵바지) 등이 특징.","['workwear style', 'american casual fashion', 'carhartt duck jacket', 'denim overalls', 'timberland boots']","['워크웨어 스타일', '아메리칸 캐주얼 패션', '칼하트 덕 자켓', '데님 오버롤 (멜빵바지)', '팀버랜드 워커']"
+military_look,밀리터리룩,"['military look', '밀리터리 스타일', '군복 패션']","군복(Military uniform)에서 영감을 받은 스타일. 카모플라주(위장) 패턴, 카고 팬츠(건빵바지), 야상 점퍼(M-65), 항공 점퍼(MA-1)가 대표 아이템.","['military fashion style', 'camouflage pattern', 'cargo pants', 'M-65 field jacket', 'MA-1 bomber jacket']","['밀리터리 패션 스타일', '카모플라주 패턴 (군복 무늬)', '카고 팬츠 (건빵바지)', '야상 점퍼', '항공 점퍼']"
+city_boy,시티보이룩,"['city boy', '시티보이', '씨티보이', '뽀빠이 매거진 스타일']","일본 '뽀빠이(Popeye)' 매거진에서 유래한 스타일. 넉넉하고 여유 있는 실루엣이 특징. 오버핏 셔츠, 치노 팬츠, 볼캡, 스니커즈 등을 주로 매치.","['japanese city boy aesthetic', 'oversized button-down shirt with wide chino pants', 'skater style mixed with preppy look', 'loose fit casual outfit with baseball cap', ""style from 'popeye' magazine""]","['일본 시티보이 스타일', '오버사이즈 셔츠와 와이드 치노 팬츠', '스케이터와 프레피가 섞인 룩', '볼캡을 매치한 루즈핏 코디', '뽀빠이 매거진 스타일']"
+kku_an_kku,꾸안꾸,"['꾸안꾸룩', 'effortless chic', 'korean natural style']","'꾸민 듯 안 꾸민 듯'의 줄임말. 편안해 보이지만(스웻셔츠, 루즈핏 니트) 실루엣이나 소재, 액세서리 등으로 은근히 멋을 낸 자연스러운 스타일.","[""korean 'kku-an-kku' style"", 'effortless chic', 'natural and simple but stylish', 'oversized sweater with simple accessories', 'casual but fashionable']","['꾸안꾸 스타일', '무심한 듯 시크한 룩', '자연스럽지만 멋스러운 코디', '오버사이즈 스웨터와 심플한 액세서리', '편안하지만 패셔너블한']"
+campus_look,캠퍼스룩,"['campus look', '대학생 코디', '프레피 캐주얼']","대학생들의 편안하면서도 단정한 스타일. 후드티, 맨투맨, 바시티 재킷(과잠), 백팩, 스니커즈, 청바지 등이 주요 아이템.","['campus look aesthetic', 'college student style', 'varsity jacket with hoodie', 'backpack and sneakers outfit', 'preppy casual look']","['캠퍼스룩 스타일', '대학생 코디', '바시티 자켓(과잠)과 후드티', '백팩과 스니커즈 코디', '프레피 캐주얼 룩']"
+one_mile_wear,원마일웨어,"['one-mile wear', '원마일웨어룩', '라운지웨어', '집 근처 패션']","집 근처 1마일(약 1.6km) 반경 내에서 입기 좋은 편안하고 실용적인 옷. 주로 스웻 셋업(트레이닝복), 후드 집업, 조거 팬츠, 레깅스 등.","['one-mile wear', 'loungewear', 'comfortable sweat suit set', 'jogger pants and hoodie zip-up', 'athleisure look']","['원마일웨어', '라운지웨어', '편안한 스웻 셋업 (트레이닝복 세트)', '조거 팬츠와 후드 집업', '애슬레저 룩']"
+mix_match,믹스매치,"['mix and match', '믹스매치룩', '스타일 믹스']","서로 다른 스타일, 소재, 패턴의 아이템을 의도적으로 혼합하여 새로운 조화를 이끌어내는 코디 방식. (예: 포멀한 재킷 + 캐주얼한 조거 팬츠)","['mix and match fashion style', 'mixing different styles', 'formal jacket with casual pants', 'pattern mixing outfit', 'unexpected combination']","['믹스매치 패션 스타일', '서로 다른 스타일 조합', '포멀한 자켓과 캐주얼한 바지', '패턴 믹스 코디', '의외의 조합']"
+sports_mix,스포츠믹스,"['sports mix', '스포츠믹스룩', '애슬레저']","믹스매치의 일종으로, 스포츠웨어(트랙 팬츠, 저지, 아노락)를 일상복(재킷, 셔츠, 코트)과 조합하는 스타일.","['sports mix style', 'athleisure fashion', 'track pants with formal jacket', 'sports jersey with coat', 'sporty and casual mix']","['스포츠믹스 스타일', '애슬레저 패션', '트랙 팬츠(추리닝)와 포멀한 자켓', '스포츠 저지와 코트 조합', '스포티 캐주얼 믹스']"