fix

app.py

@@ -1,4 +1,3 @@
-
 import streamlit as st
 import json
 import os
@@ -15,12 +14,16 @@ import matplotlib.pyplot as plt
 import matplotlib.font_manager as fm
 from sklearn.manifold import TSNE
 import warnings
+import gensim # FastText 사용을 위한 gensim import
+import hashlib # 캐시 키 생성을 위해 추가
+
 warnings.filterwarnings('ignore')
 
+# --- 기본 설정 ---
 # 페이지 설정
 st.set_page_config(
-    page_title="한국어 단어 의미 네트워크 시각화",
-    page_icon="🔤",
+    page_title="한국어 단어 의미 네트워크 시각화 (FastText)",
+    page_icon="🧠", # 아이콘 변경
     layout="wide"
 )
 
@@ -29,100 +32,122 @@ DATA_FOLDER = 'data'
 UPLOAD_FOLDER = 'uploads'
 
 # 폴더 생성
+if not os.path.exists(DATA_FOLDER):
+    os.makedirs(DATA_FOLDER)
 if not os.path.exists(UPLOAD_FOLDER):
     os.makedirs(UPLOAD_FOLDER)
 
-# 세션 상태 초기화
-if 'model' not in st.session_state:
-    st.session_state.model = None
-    
+
+# --- FastText 모델 설정 ---
+# !!! 사용자 필수 설정 !!!
+# 다운로드한 한국어 FastText 모델 파일(.bin)의 전체 경로를 지정하세요.
+# 예시: "C:/Users/YourUser/Downloads/cc.ko.300.bin" 또는 "/home/user/models/cc.ko.300.bin"
+# 모델 다운로드: https://fasttext.cc/docs/en/crawl-vectors.html 등 참조
+FASTTEXT_MODEL_PATH = "YOUR_PATH_TO/cc.ko.300.bin" # <--- 여기에 실제 파일 경로 입력!!!
+
+
+# --- 세션 상태 초기화 ---
+if 'fasttext_model' not in st.session_state:
+    st.session_state.fasttext_model = None # 모델 객체 저장
 if 'embeddings_cache' not in st.session_state:
-    st.session_state.embeddings_cache = {}
-    
+    st.session_state.embeddings_cache = {} # 임베딩 캐시는 단어 목록+모델 기반으로 재고려 가능 (여기선 단순화)
 if 'graph_cache' not in st.session_state:
     st.session_state.graph_cache = {}
-    
 if 'data_files' not in st.session_state:
     st.session_state.data_files = {}
-
 if 'selected_files' not in st.session_state:
     st.session_state.selected_files = []
-
 if 'threshold' not in st.session_state:
-    st.session_state.threshold = 0.7
+    st.session_state.threshold = 0.6 # 의미 기반이므로 임계값 기본값 조정 가능
+if 'perplexity' not in st.session_state:
+    st.session_state.perplexity = 30
+if 'learning_rate' not in st.session_state:
+    st.session_state.learning_rate = 'auto'
+if 'n_iter' not in st.session_state:
+    st.session_state.n_iter = 1000
+if 'generate_clicked' not in st.session_state:
+    st.session_state.generate_clicked = False
+if 'fig' not in st.session_state:
+    st.session_state.fig = None
+
+
+# --- FastText 모델 로딩 함수 (캐싱 사용) ---
+@st.cache_resource # 모델 객체는 크므로 리소스 캐싱 사용
+def load_fasttext_model(model_path):
+    """지정된 경로에서 FastText 모델을 로드합니다."""
+    if not os.path.exists(model_path):
+        st.error(f"오류: FastText 모델 파일을 찾을 수 없습니다: {model_path}")
+        st.error("FastText 웹사이트 등에서 한국어 모델(cc.ko.300.bin 추천)을 다운로드하고 코드 상단의 `FASTTEXT_MODEL_PATH` 변수를 정확히 지정해주세요.")
+        return None
+    try:
+        st.info(f"FastText 모델 로딩 중... ({os.path.basename(model_path)}) 모델 크기에 따라 시간이 걸릴 수 있습니다.")
+        # .bin 파일 로드를 위해 load_facebook_model 사용
+        model = gensim.models.fasttext.load_facebook_model(model_path)
+        st.info("FastText 모델 로딩 완료.")
+        return model
+    except Exception as e:
+        st.error(f"FastText 모델 로딩 중 오류 발생: {e}")
+        return None
 
 # --- 한글 폰트 설정 함수 ---
 def set_korean_font():
-    """
-    현재 운영체제에 맞는 한글 폰트를 matplotlib 및 Plotly용으로 설정 시도하고,
-    Plotly에서 사용할 폰트 이름을 반환합니다.
-    """
+    """ 운영체제에 맞는 한글 폰트를 설정하고 Plotly용 폰트 이름을 반환합니다. """
     system_name = platform.system()
-    plotly_font_name = None # Plotly에서 사용할 폰트 이름
-
-    # Matplotlib 폰트 설정
-    if system_name == "Windows":
-        font_name = "Malgun Gothic"
-        plotly_font_name = "Malgun Gothic"
-    elif system_name == "Darwin":  # MacOS
-        font_name = "AppleGothic"
-        plotly_font_name = "AppleGothic"
-    elif system_name == "Linux":
-        # Linux에서 선호하는 한글 폰트 경로 또는 이름 설정
-        font_path = "/usr/share/fonts/truetype/nanum/NanumGothic.ttf"
-        plotly_font_name_linux = "NanumGothic" # Plotly는 폰트 '이름'을 주로 사용
-
-        if os.path.exists(font_path):
-            font_name = fm.FontProperties(fname=font_path).get_name()
-            plotly_font_name = plotly_font_name_linux
-        else:
-            # 시스템에서 'Nanum' 포함 폰트 찾기 시도
-            try:
+    plotly_font_name = 'sans-serif' # 기본값
+
+    try:
+        if system_name == "Windows":
+            font_name = "Malgun Gothic"
+            plotly_font_name = "Malgun Gothic"
+        elif system_name == "Darwin":  # MacOS
+            font_name = "AppleGothic"
+            plotly_font_name = "AppleGothic"
+        elif system_name == "Linux":
+            # 시스템에서 Nanum 폰트 찾기 시도
+            font_path = None
+            possible_paths = [
+                "/usr/share/fonts/truetype/nanum/NanumGothic.ttf",
+                "/usr/share/fonts/nanum/NanumGothic.ttf",
+                # 다른 경로 추가 가능
+            ]
+            for path in possible_paths:
+                if os.path.exists(path):
+                    font_path = path
+                    break
+
+            if font_path:
+                fm.fontManager.addfont(font_path)
+                prop = fm.FontProperties(fname=font_path)
+                font_name = prop.get_name()
+                plotly_font_name = font_name # Plotly는 이름 사용
+            else: # 시스템 폰트 매니저에서 검색
                 available_fonts = [f.name for f in fm.fontManager.ttflist]
                 nanum_fonts = [name for name in available_fonts if 'Nanum' in name]
                 if nanum_fonts:
                     font_name = nanum_fonts[0]
-                    # Plotly에서 사용할 이름도 비슷하게 설정 (정확한 이름은 시스템마다 다를 수 있음)
-                    plotly_font_name = font_name if 'Nanum' in font_name else plotly_font_name_linux
+                    plotly_font_name = font_name
                 else:
-                    # 다른 OS 폰트 시도
-                    if "Malgun Gothic" in available_fonts:
-                        font_name = "Malgun Gothic"
-                        plotly_font_name = "Malgun Gothic"
-                    elif "AppleGothic" in available_fonts:
-                        font_name = "AppleGothic"
-                        plotly_font_name = "AppleGothic"
-                    else:
-                        font_name = None
-
-            except Exception as e:
-                font_name = None
-
-            if not font_name:
-                font_name = None
-                plotly_font_name = None # Plotly도 기본값 사용
-
-    else:  # 기타 OS
-        font_name = None
-        plotly_font_name = None
+                    font_name = None # 찾기 실패
+        else:
+            font_name = None
 
-    # Matplotlib 폰트 설정 적용
-    if font_name:
-        try:
+        # Matplotlib 설정 적용
+        if font_name:
             plt.rc('font', family=font_name)
             plt.rc('axes', unicode_minus=False)
-        except Exception as e:
+            print(f"Matplotlib font set to: {font_name}")
+        else:
+            print("Suitable Korean font not found for Matplotlib. Using default.")
             plt.rcdefaults()
             plt.rc('axes', unicode_minus=False)
-    else:
+
+    except Exception as e:
+        print(f"Error setting Korean font: {e}")
         plt.rcdefaults()
         plt.rc('axes', unicode_minus=False)
 
-    if not plotly_font_name:
-        plotly_font_name = 'sans-serif' # Plotly 기본값 지정
-
-    return plotly_font_name # Plotly에서 사용할 폰트 이름 반환
-
+    print(f"Plotly font name to use: {plotly_font_name}")
+    return plotly_font_name
 
 # --- 데이터 로드 함수 ---
 def load_words_from_json(filepath):
@@ -130,190 +155,263 @@ def load_words_from_json(filepath):
     try:
         with open(filepath, 'r', encoding='utf-8') as f:
             data = json.load(f)
-        # data가 리스트 형태라고 가정
         if isinstance(data, list):
-             words = [item.get('word', '') for item in data if item.get('word')]
-             # 빈 문자열 제거
-             words = [word for word in words if word]
+             words = [item.get('word', '') for item in data if isinstance(item, dict) and item.get('word')]
+             words = [word for word in words if word] # 빈 문자열 제거
+             if not words:
+                 st.warning(f"경고: 파일 '{os.path.basename(filepath)}'에서 'word' 키를 가진 유효한 데이터를 찾을 수 없습니다.")
+                 return None
              return words
         else:
-            st.error(f"오류: 파일 '{filepath}'의 최상위 형식이 리스트가 아닙니다.")
+            st.error(f"오류: 파일 '{os.path.basename(filepath)}'의 최상위 형식이 리스트가 아닙니다.")
             return None
     except FileNotFoundError:
         st.error(f"오류: 파일 '{filepath}'를 찾을 수 없습니다.")
         return None
-    except json.JSONDecodeError:
-        st.error(f"오류: 파일 '{filepath}'의 JSON 형식이 잘못되었습니다.")
+    except json.JSONDecodeError as e:
+        st.error(f"오류: 파일 '{os.path.basename(filepath)}'의 JSON 형식이 잘못되었습니다. 오류: {e}")
         return None
     except Exception as e:
-        st.error(f"데이터 로딩 중 오류 발생: {e}")
+        st.error(f"'{os.path.basename(filepath)}' 데��터 로딩 중 오류 발생: {e}")
         return None
 
-
 def scan_data_files():
-    """데이터 폴더에서 사용 가능한 모든 JSON 파일을 스캔하고 정보를 반환합니다."""
+    """데이터 폴더 및 업로드 폴더에서 사용 가능한 JSON 파일을 스캔합니다."""
     data_files = {}
-    
-    # 기본 데이터 폴더 스캔
-    for file_path in glob.glob(os.path.join(DATA_FOLDER, '*.json')):
-        file_id = str(uuid.uuid4())
-        file_name = os.path.basename(file_path)
-        words = load_words_from_json(file_path)
-        if words:
-            data_files[file_id] = {
-                'path': file_path,
-                'name': file_name,
-                'word_count': len(words),
-                'type': 'default',
-                'sample_words': words[:5] if len(words) > 5 else words
-            }
-    
-    # 업로드 폴더 스캔
-    for file_path in glob.glob(os.path.join(UPLOAD_FOLDER, '*.json')):
-        file_id = str(uuid.uuid4())
-        file_name = os.path.basename(file_path)
-        words = load_words_from_json(file_path)
-        if words:
-            data_files[file_id] = {
-                'path': file_path,
-                'name': file_name,
-                'word_count': len(words),
-                'type': 'uploaded',
-                'sample_words': words[:5] if len(words) > 5 else words
-            }
-    
+    # 기본 데이터 폴더
+    try:
+        for file_path in glob.glob(os.path.join(DATA_FOLDER, '*.json')):
+            file_id = f"default_{os.path.basename(file_path)}"
+            file_name = os.path.basename(file_path)
+            words = load_words_from_json(file_path)
+            if words:
+                data_files[file_id] = {'path': file_path, 'name': file_name, 'word_count': len(words), 'type': 'default', 'sample_words': words[:5]}
+    except Exception as e:
+        st.error(f"기본 데이터 폴더 스캔 중 오류: {e}")
+    # 업로드 폴더
+    try:
+        for file_path in glob.glob(os.path.join(UPLOAD_FOLDER, '*.json')):
+            file_id = f"uploaded_{os.path.basename(file_path)}"
+            file_name = os.path.basename(file_path)
+            words = load_words_from_json(file_path)
+            if words:
+                data_files[file_id] = {'path': file_path, 'name': file_name, 'word_count': len(words), 'type': 'uploaded', 'sample_words': words[:5]}
+    except Exception as e:
+        st.error(f"업로드 폴더 스캔 중 오류: {e}")
     return data_files
 
-
-def merge_word_lists(file_ids):
+def merge_word_lists(file_ids, current_data_files):
     """선택된 파일들에서 단어를 로드하고 중복 제거하여 병합합니다."""
-    all_words = []
-    
+    all_words = set() # 중복 제거를 위해 set 사용
+    if not file_ids:
+        return []
+
     for file_id in file_ids:
-        if file_id in st.session_state.data_files:
-            file_path = st.session_state.data_files[file_id]['path']
+        if file_id in current_data_files:
+            file_path = current_data_files[file_id]['path']
             words = load_words_from_json(file_path)
             if words:
-                all_words.extend(words)
-    
-    # 중복 제거 및 정렬
-    unique_words = sorted(list(set(all_words)))
+                all_words.update(words) # set에 추가
+        else:
+            st.warning(f"선택된 파일 ID '{file_id}'를 찾을 수 없습니다. 목록을 새로고침합니다.")
+            # 파일 목록 재스캔 로직은 복잡해질 수 있으므로 여기서는 경고만 표시
+    # 정렬된 리스트로 반환
+    unique_words = sorted(list(all_words))
     return unique_words
 
+# --- 단어 임베딩 함수 (FastText 사용) ---
+def encode_words_fasttext(words, normalize=True):
+    """FastText 모델을 사용하여 단어 목록을 의미 임베딩으로 변환합니다."""
+    model = st.session_state.get('fasttext_model')
+
+    if model is None:
+        st.error("FastText 모델이 로드되지 않아 임베딩을 생성할 수 없습니다.")
+        return None
+
+    if not words:
+        return np.array([])
 
-def encode_words(words, normalize=True):
-    """단어 목록을 임베딩으로 변환합니다."""
-    # 간단한 TF-IDF 스타일 임베딩 생성 (임시)
     embeddings = []
-    vocab = set(" ".join(words))
-    dim = len(vocab)
-    
-    char_to_idx = {char: i for i, char in enumerate(sorted(vocab))}
-    
-    for word in words:
-        embed = np.zeros(dim)
-        for char in word:
-            if char in char_to_idx:
-                embed[char_to_idx[char]] += 1
-        
-        # 정규화 (선택적)
-        if normalize and np.sum(embed) > 0:
-            embed = embed / np.linalg.norm(embed)
-            
-        embeddings.append(embed)
-    
-    return np.array(embeddings)
-
-
-def generate_graph(file_ids, similarity_threshold=0.7):
-    """여러 파일에서 단어를 로드하고 그래프를 생성합니다."""
-    # 캐시 키 생성 (파일 ID와 임계값 조합)
-    cache_key = f"{'-'.join(sorted(file_ids))}_{similarity_threshold}"
+    oov_count = 0
+    vector_size = model.vector_size
+
+    with st.spinner(f"단어 {len(words)}개에 대한 의미 임베딩 생성 중 (FastText)..."):
+        for word in words:
+            try:
+                vector = model.wv[word]
+                if np.all(vector == 0):
+                    oov_count += 1
+                if normalize:
+                    norm = np.linalg.norm(vector)
+                    vector = vector / norm if norm > 0 else np.zeros(vector_size)
+                embeddings.append(vector)
+            except Exception as e:
+                st.warning(f"단어 '{word}' 처리 중 오류 발생 (혹은 OOV): {e}. 0벡터로 대체합니다.")
+                embeddings.append(np.zeros(vector_size))
+                oov_count += 1
+
+    if oov_count > 0:
+        st.warning(f"총 {len(words)}개 단어 중 {oov_count}개에 대해 유효 벡터를 얻지 못했습니다(OOV 등).")
+
+    result_embeddings = np.array(embeddings)
+
+    if result_embeddings.size == 0 and len(words) > 0:
+         st.error("임베딩 생성 결과가 비어 있습니다.")
+         return None
+    elif result_embeddings.shape[0] != len(words):
+         st.error(f"입력 단어 수({len(words)})와 생성된 임베딩 수({result_embeddings.shape[0]}) 불일치.")
+         return None
+
+    return result_embeddings
+
+# --- 그래프 생성 함수 ---
+def generate_graph(file_ids, similarity_threshold, perplexity, learning_rate, n_iter):
+    """ 의미 유사성 기반 3D 그래프를 생성합니다. """
+    # 그래프 캐시 키 생성 (파일 ID, 임계값, t-SNE 파라미터 포함)
+    param_str = f"t{similarity_threshold}_p{perplexity}_lr{learning_rate}_i{n_iter}"
+    sorted_fids = "-".join(sorted(file_ids))
+    # 단어 목록 자체를 해시하여 캐시 키에 포함 (더 정확하지만 느릴 수 있음)
+    # word_list_for_key = merge_word_lists(file_ids, st.session_state.data_files)
+    # word_hash = hashlib.sha256(str(word_list_for_key).encode()).hexdigest()[:8]
+    # cache_key = f"{sorted_fids}_{word_hash}_{param_str}_fasttext"
+    cache_key = f"{sorted_fids}_{param_str}_fasttext" # 파일 ID 기반 캐시
+
     if cache_key in st.session_state.graph_cache:
+        st.info("캐시된 그래프를 사용합니다.")
         return st.session_state.graph_cache[cache_key]
-    
-    # 한글 폰트 설정
-    plotly_font = set_korean_font()
-    
-    # 선택된 파일들에서 단어 로드 및 병합
-    word_list = merge_word_lists(file_ids)
-    
+
+    # --- 필요 데이터 로드 및 검증 ---
+    if not file_ids:
+        st.error("그래프를 생성할 파일이 선택되지 않았습니다.")
+        return None
+    if st.session_state.get('fasttext_model') is None:
+        st.error("FastText 모델이 로드되지 않아 그래프 생성을 진행할 수 없습니다.")
+        return None
+
+    plotly_font = set_korean_font() # 한글 폰트 설정
+    word_list = merge_word_lists(file_ids, st.session_state.data_files) # 단어 목록 병합
+
     if not word_list:
-        st.error("데이터를 로드할 수 없습니다.")
+        st.error("선택된 파일에서 유효한 단어를 로드할 수 없습니다.")
+        return None
+    if len(word_list) < 2:
+        st.warning("그래프를 생성하려면 최소 2개 이상의 고유 단어가 필요합니다.")
+        return None
+
+    # --- 임베딩 생성 ---
+    embeddings = encode_words_fasttext(word_list, normalize=True)
+    if embeddings is None or embeddings.shape[0] == 0 or embeddings.shape[1] == 0:
+        st.error("유효한 단어 임베딩 생성 실패.")
         return None
-    
-    # 임베딩 생성
-    with st.spinner('임베딩 생성 중...'):
-        embeddings = encode_words(word_list, normalize=True)
-    
-    # 3D 좌표 생성 - t-SNE 사용
-    with st.spinner('차원 축소 중 (t-SNE)...'):
-        effective_perplexity = min(30, len(word_list) - 1)
-        if effective_perplexity <= 0:
-            effective_perplexity = 5  # 매우 작은 데이터셋 대비
-        
-        tsne = TSNE(n_components=3, random_state=42, perplexity=effective_perplexity, 
-                   max_iter=1000, init='pca', learning_rate='auto')
-        embeddings_3d = tsne.fit_transform(embeddings)
-    
-    # 유사도 계산 및 엣지 정의
-    with st.spinner('유사도 계산 중...'):
-        similarity_matrix = cosine_similarity(embeddings)
-    
-        edges = []
-        edge_weights = []
-        for i in range(len(word_list)):
-            for j in range(i + 1, len(word_list)):
-                similarity = similarity_matrix[i, j]
-                if similarity > similarity_threshold:
-                    edges.append((word_list[i], word_list[j]))
-                    edge_weights.append(similarity)
-    
-    # NetworkX 그래프 생성
+
+    # --- 차원 축소 (t-SNE) ---
+    embeddings_3d = None
+    n_samples = embeddings.shape[0]
+    with st.spinner(f'단어 {n_samples}개 좌표 계산 중 (t-SNE)...'):
+        effective_perplexity = min(perplexity, max(5, n_samples - 1))
+        if effective_perplexity != perplexity:
+             st.warning(f"Perplexity가 샘플 수에 맞게 {effective_perplexity}(으)로 조정되었습니다.")
+        effective_lr = learning_rate if isinstance(learning_rate, (int, float)) else 200.0 if learning_rate == 'auto' else learning_rate
+        effective_iter = n_iter
+
+        if n_samples <= 3:
+            st.warning(f"단어 수가 {n_samples}개로 적어 PCA를 사용합니다.")
+            from sklearn.decomposition import PCA
+            pca = PCA(n_components=min(3, n_samples), random_state=42)
+            embeddings_3d_pca = pca.fit_transform(embeddings)
+            embeddings_3d = np.zeros((n_samples, 3))
+            embeddings_3d[:, :embeddings_3d_pca.shape[1]] = embeddings_3d_pca
+        else:
+            try:
+                tsne = TSNE(n_components=3, random_state=42,
+                            perplexity=effective_perplexity,
+                            n_iter=effective_iter,
+                            init='pca',
+                            learning_rate=effective_lr,
+                            n_jobs=-1)
+                embeddings_3d = tsne.fit_transform(embeddings)
+            except Exception as e:
+                st.error(f"t-SNE 오류: {e}. PCA로 대체합니다.")
+                from sklearn.decomposition import PCA
+                pca = PCA(n_components=3, random_state=42)
+                embeddings_3d = pca.fit_transform(embeddings) # PCA로 재시도
+
+    if embeddings_3d is None or embeddings_3d.shape[0] != len(word_list):
+        st.error("단어 3D 좌표 생성 실패.")
+        return None
+
+    # --- 유사도 계산 및 그래프 구성 ---
+    edges = []
+    edge_weights = []
+    with st.spinner('단어 간 의미 유사도 계산 및 연결 생성 중...'):
+        try:
+             similarity_matrix = cosine_similarity(embeddings)
+             for i in range(n_samples):
+                 for j in range(i + 1, n_samples):
+                     similarity = similarity_matrix[i, j]
+                     if not np.isnan(similarity) and similarity >= similarity_threshold:
+                         edges.append((word_list[i], word_list[j]))
+                         edge_weights.append(similarity)
+        except Exception as e:
+             st.error(f"유사도 계산 중 오류 발생: {e}")
+             return None
+
+    # --- NetworkX 그래프 생성 ---
     G = nx.Graph()
+    valid_nodes_count = 0
     for i, word in enumerate(word_list):
-        G.add_node(word, pos=(embeddings_3d[i, 0], embeddings_3d[i, 1], embeddings_3d[i, 2]))
-    
-    # 엣지와 가중치 추가
+        if i < embeddings_3d.shape[0]: # 좌표가 생성된 노드만 추가
+            G.add_node(word, pos=(embeddings_3d[i, 0], embeddings_3d[i, 1], embeddings_3d[i, 2]))
+            valid_nodes_count += 1
+        else:
+             st.warning(f"'{word}' 단어 좌표 누락.") # 누락 경고
+
+    if valid_nodes_count != len(word_list):
+         st.warning(f"{len(word_list)-valid_nodes_count}개 단어 노드 생성 실패.")
+
+    valid_edges_count = 0
     for edge, weight in zip(edges, edge_weights):
-        G.add_edge(edge[0], edge[1], weight=weight)
-    
-    # Plotly 그래프 생성
-    # 엣지 좌표 추출
-    edge_x = []
-    edge_y = []
-    edge_z = []
-    if edges:
+        if G.has_node(edge[0]) and G.has_node(edge[1]): # 노드가 있는지 확인 후 엣지 추가
+            G.add_edge(edge[0], edge[1], weight=weight)
+            valid_edges_count += 1
+
+    # --- Plotly 시각화 객체 생성 ---
+    edge_x, edge_y, edge_z = [], [], []
+    if G.number_of_edges() > 0:
         for edge in G.edges():
-            x0, y0, z0 = G.nodes[edge[0]]['pos']
-            x1, y1, z1 = G.nodes[edge[1]]['pos']
-            edge_x.extend([x0, x1, None])
-            edge_y.extend([y0, y1, None])
-            edge_z.extend([z0, z1, None])
-        
-        # 엣지용 Scatter3d 트레이스 생성
-        edge_trace = go.Scatter3d(
-            x=edge_x, y=edge_y, z=edge_z,
-            mode='lines',
-            line=dict(width=1, color='#888'),
-            hoverinfo='none'
-        )
-    else:
-        edge_trace = go.Scatter3d(x=[], y=[], z=[], mode='lines')
-    
-    # 노드 위치와 텍스트 추출
-    node_x = [G.nodes[node]['pos'][0] for node in G.nodes()]
-    node_y = [G.nodes[node]['pos'][1] for node in G.nodes()]
-    node_z = [G.nodes[node]['pos'][2] for node in G.nodes()]
-    node_text = list(G.nodes())
-    node_adjacencies = []
-    node_hover_text = []
-    for node, adjacencies in enumerate(G.adjacency()):
-        num_connections = len(adjacencies[1])
-        node_adjacencies.append(num_connections)
-        node_hover_text.append(f'{node_text[node]}<br>연결: {num_connections}개')
-    
-    # 노드용 Scatter3d 트레이스 생성
+            try:
+                pos0 = G.nodes[edge[0]]['pos']
+                pos1 = G.nodes[edge[1]]['pos']
+                edge_x.extend([pos0[0], pos1[0], None])
+                edge_y.extend([pos0[1], pos1[1], None])
+                edge_z.extend([pos0[2], pos1[2], None])
+            except KeyError as e:
+                 st.warning(f"엣지 {edge} 생성 중 노드 위치 오류: {e}")
+                 continue
+
+    edge_trace = go.Scatter3d(x=edge_x, y=edge_y, z=edge_z, mode='lines', line=dict(width=1, color='#888'), hoverinfo='none')
+
+    node_x, node_y, node_z, node_text, node_hover_text, node_sizes = [], [], [], [], [], []
+    if G.number_of_nodes() > 0:
+        degrees = np.array([G.degree(node) for node in G.nodes()])
+        # 로그 스케일링 + 크기 제한
+        raw_sizes = np.log1p(degrees) * 3 + 6
+        node_sizes_list = np.clip(raw_sizes, 5, 20).tolist()
+
+        for i, node in enumerate(G.nodes()):
+            try:
+                pos = G.nodes[node]['pos']
+                degree = G.degree(node)
+                node_x.append(pos[0])
+                node_y.append(pos[1])
+                node_z.append(pos[2])
+                node_text.append(node)
+                node_hover_text.append(f'{node}<br>연결 수: {degree}')
+                # node_sizes 리스트는 이미 위에서 계산됨
+            except KeyError:
+                 st.warning(f"노드 '{node}' 위치 정보 오류.")
+                 continue # 해당 노드 건너뛰기
+
     node_trace = go.Scatter3d(
         x=node_x, y=node_y, z=node_z,
         mode='markers+text',
@@ -321,294 +419,341 @@ def generate_graph(file_ids, similarity_threshold=0.7):
         hovertext=node_hover_text,
         hoverinfo='text',
         textposition='top center',
-        textfont=dict(
-            size=10,
-            color='black',
-            family=plotly_font
-        ),
+        textfont=dict(size=10, color='black', family=plotly_font),
         marker=dict(
-            size=6,
-            color=node_z,
+            size=node_sizes_list if node_sizes_list else 5, # 계산된 크기 사용
+            color=node_z, # Z값으로 색상 매핑
             colorscale='Viridis',
             opacity=0.9,
-            colorbar=dict(thickness=15, title='Node Depth (Z-axis)', xanchor='left', title_side='right')
+            colorbar=dict(thickness=15, title='Node Depth (Z)', xanchor='left', titleside='right')
         )
     )
-    
-    # 파일 정보 문자열 생성
-    file_names = [st.session_state.data_files[file_id]['name'] for file_id in file_ids 
-                 if file_id in st.session_state.data_files]
-    file_info = ", ".join(file_names)
-    
-    # 레이아웃 설정
+
+    # --- 레이아웃 설정 및 Figure 생성 ---
+    current_data_files = st.session_state.get('data_files', {})
+    file_names_used = [current_data_files[fid]['name'] for fid in file_ids if fid in current_data_files]
+    file_info_str = ", ".join(file_names_used) if file_names_used else "알 수 없음"
+
     layout = go.Layout(
         title=dict(
-            text=f'어휘 의미 유사성 기반 3D 그래프 (Threshold: {similarity_threshold})<br>데이터: {file_info}',
-            font=dict(size=16, family=plotly_font)
+            text=f'<b>어휘 의미 유사성 기반 3D 그래프 (FastText)</b><br>Threshold: {similarity_threshold:.2f} | 데이터: {file_info_str}',
+            font=dict(size=16, family=plotly_font),
+            x=0.5, xanchor='center'
         ),
         showlegend=False,
-        margin=dict(b=20, l=5, r=5, t=80),  # 제목 높이 확보를 위해 t 값 증가
+        margin=dict(l=10, r=10, b=10, t=80),
         scene=dict(
-            xaxis=dict(title='TSNE Dimension 1', showticklabels=False, backgroundcolor="rgb(230, 230,230)", 
-                      gridcolor="white", zerolinecolor="white"),
-            yaxis=dict(title='TSNE Dimension 2', showticklabels=False, backgroundcolor="rgb(230, 230,230)", 
-                      gridcolor="white", zerolinecolor="white"),
-            zaxis=dict(title='TSNE Dimension 3', showticklabels=False, backgroundcolor="rgb(230, 230,230)", 
-                      gridcolor="white", zerolinecolor="white"),
-            aspectratio=dict(x=1, y=1, z=0.8)
-        )
+            xaxis=dict(title='TSNE-1', showticklabels=False, backgroundcolor="rgb(230, 230, 230)", gridcolor="white", zerolinecolor="white"),
+            yaxis=dict(title='TSNE-2', showticklabels=False, backgroundcolor="rgb(230, 230, 230)", gridcolor="white", zerolinecolor="white"),
+            zaxis=dict(title='TSNE-3', showticklabels=False, backgroundcolor="rgb(230, 230, 230)", gridcolor="white", zerolinecolor="white"),
+            aspectratio=dict(x=1, y=1, z=0.8),
+            camera=dict(eye=dict(x=1.2, y=1.2, z=0.8))
+        ),
+        hovermode='closest'
     )
-    
-    # Figure 생성
+
     fig = go.Figure(data=[edge_trace, node_trace], layout=layout)
-    
-    # 결과 캐시 저장
+
+    # 그래프 캐시 저장
     st.session_state.graph_cache[cache_key] = fig
-    
-    return fig
 
+    return fig
 
+# --- 파일 처리 함수 ---
 def handle_uploaded_file(uploaded_file):
-    """업로드된 파일을 처리하��� 데이터 파일 목록에 추가합니다."""
+    """ 업로드된 파일을 처리하고 data_files 목록을 갱신합니다. """
     if uploaded_file is not None:
-        # 파일명 안전 처리 및 저장
-        timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
-        file_name = f"{timestamp}_{uploaded_file.name}"
+        unique_id = str(uuid.uuid4())
+        file_name = f"{unique_id}_{uploaded_file.name}"
         file_path = os.path.join(UPLOAD_FOLDER, file_name)
-        
+
         try:
-            # 파일 저장
             with open(file_path, 'wb') as f:
                 f.write(uploaded_file.getbuffer())
-            
-            # 업로드된 파일 검증
+            st.info(f"파일 '{uploaded_file.name}' 저장 완료. 내용 검증 중...")
+
             words = load_words_from_json(file_path)
-            if not words:
-                os.remove(file_path)  # 잘못된 형식이면 파일 삭제
-                st.error('업로드된 파일에서 단어를 찾을 수 없습니다. 파일 형식을 확인하세요.')
+            if words is None or not words :
+                os.remove(file_path)
+                st.error(f"업로드된 파일 '{uploaded_file.name}'에서 유효한 'word' 데이터를 찾을 수 없습니다. 삭제되었습니다.")
                 return None
-            
-            # 데이터 파일 다시 스캔하여 새 파일 정보 포함
-            st.session_state.data_files = scan_data_files()
-            
-            # 새 파일에 해당하는 file_id 찾기
-            new_file_id = None
-            for file_id, file_info in st.session_state.data_files.items():
-                if file_info['path'] == file_path:
-                    new_file_id = file_id
-                    break
-            
-            return new_file_id
-            
+            else:
+                st.success(f"파일 '{uploaded_file.name}' 검증 완료 ({len(words)} 단어).")
+                # 데이터 파일 목록 즉시 갱신
+                st.session_state.data_files = scan_data_files()
+                new_file_id = f"uploaded_{file_name}"
+                return new_file_id
         except Exception as e:
-            # 오류 발생 시 업로드된 파일 삭제 시도
-            try:
-                if os.path.exists(file_path):
-                    os.remove(file_path)
-            except:
-                pass
-            st.error(f'파일 업로드 중 오류가 발생했습니다: {str(e)}')
+            st.error(f"파일 업로드 처리 중 오류: {e}")
+            if os.path.exists(file_path): os.remove(file_path) # 오류 시 파일 삭제
             return None
 
-
 def delete_file(file_id):
-    """파일을 삭제합니다."""
-    if file_id not in st.session_state.data_files:
-        st.error('파일을 찾을 수 없습니다.')
+    """ 업로드된 파일을 삭제하고 관련 캐시를 정리합니다. """
+    current_data_files = st.session_state.get('data_files', {})
+    if file_id not in current_data_files:
+        st.error('삭제할 파일을 찾을 수 없습니다.')
         return False
-    
-    file_info = st.session_state.data_files[file_id]
-    
-    # 업로드된 파일만 삭제 허용
-    if file_info['type'] != 'uploaded':
+
+    file_info = current_data_files[file_id]
+    if file_info.get('type') != 'uploaded':
         st.error('기본 데이터 파일은 삭제할 수 없습니다.')
         return False
-    
-    # 파일 삭제
-    file_path = file_info['path']
-    if os.path.exists(file_path):
-        os.remove(file_path)
-    
-    # 데이터 파일 정보 업데이트
-    st.session_state.data_files.pop(file_id)
-    
-    # 관련 캐시 항목 삭제
-    keys_to_remove = []
-    for cache_key in st.session_state.graph_cache:
-        if file_id in cache_key:
-            keys_to_remove.append(cache_key)
-    
-    for key in keys_to_remove:
-        st.session_state.graph_cache.pop(key)
-    
-    # 선택된 파일 목록에서도 제거
-    if file_id in st.session_state.selected_files:
-        st.session_state.selected_files.remove(file_id)
-    
-    return True
 
+    file_path = file_info.get('path')
+    file_name = file_info.get('name', '알 수 없음')
+
+    try:
+        if file_path and os.path.exists(file_path):
+            os.remove(file_path)
+            st.info(f"파일 '{file_name}' 삭제 완료.")
+        else:
+             st.warning(f"파일 '{file_name}'({file_path})을 찾을 수 없거나 이미 삭제되었습니다.")
+
+        # 세션 상태 업데이트
+        del st.session_state.data_files[file_id]
+        if file_id in st.session_state.selected_files:
+            st.session_state.selected_files.remove(file_id)
+
+        # 관련 그래프 캐시 삭제 (키에 file_id가 포함된 항목)
+        keys_to_remove = [k for k in st.session_state.graph_cache if file_id in k.split('_')[0]] # 키 형식 가정
+        for key in keys_to_remove:
+            del st.session_state.graph_cache[key]
+        if keys_to_remove: st.info(f"{len(keys_to_remove)}개 관련 그래프 캐시 삭제.")
 
+        st.success(f"'{file_name}' 관련 정보 및 캐시 삭제 완료.")
+        return True
+
+    except Exception as e:
+        st.error(f"파일 삭제 중 오류 발생: {e}")
+        return False
+
+# --- 캐시 초기화 함수 ---
 def clear_cache():
-    """캐시를 초기화합니다."""
+    """ 그래프 캐시를 초기화합니다. """
     st.session_state.graph_cache = {}
-    st.session_state.embeddings_cache = {}
-    st.success('캐시가 초기화되었습니다.')
+    # st.session_state.embeddings_cache = {} # 임베딩 캐시는 현재 사용 안 함
+    st.session_state.fig = None
+    st.success('그래프 캐시가 초기화되었습니다.')
+    st.rerun() # UI 갱신
+
+
+# ==============================================================================
+# --- Streamlit 앱 실행 부분 ---
+# ==============================================================================
 
+# --- 앱 시작 시 초기화 ---
+# FastText 모델 로드 시도
+if 'fasttext_model' not in st.session_state or st.session_state.fasttext_model is None:
+     st.session_state.fasttext_model = load_fasttext_model(FASTTEXT_MODEL_PATH)
 
 # 데이터 파일 스캔
-st.session_state.data_files = scan_data_files()
+if 'data_files' not in st.session_state or not st.session_state.data_files:
+    st.session_state.data_files = scan_data_files()
 
 # 타이틀 및 소개
-st.title('한국어 단어 의미 네트워크 시각화')
-st.markdown('이 도구는 한국어 단어들 간의 의미적 관계를 3D 공간에서 시각화합니다.')
+st.title('한국어 단어 의미 네트워크 시각화 (FastText 기반)')
+st.markdown("""
+이 도구는 JSON 파일의 단어 목록을 **FastText 임베딩**으로 변환하여 의미적 유사성을 계산하고, 그 관계를 3D 네트워크 그래프로 시각화합니다.
+유사한 의미의 단어들이 서로 가깝게 배치되는 경향을 보입니다.
+""")
 
-# 사이드바 설정
-st.sidebar.title('설정')
+# 모델 로딩 상태 확인
+if st.session_state.get('fasttext_model') is None:
+    st.error("FastText 모델 로딩 실패. 코드 상단의 `FASTTEXT_MODEL_PATH` 설정을 확인하고 앱을 재실행해주세요.")
+    st.stop() # 모델 없으면 앱 중단
 
-# 임계값 설정
-threshold = st.sidebar.slider(
-    '유사도 임계값', 
-    min_value=0.1, 
-    max_value=0.9, 
-    value=st.session_state.threshold,
-    step=0.05,
-    help='높은 값 = 더 엄격한 연결 기준 (적은 엣지)'
-)
-st.session_state.threshold = threshold
 
-# 파일 업로드
-st.sidebar.header('파일 업로드')
-uploaded_file = st.sidebar.file_uploader("JSON 파일 선택", type=['json'], help="'word' 필드를 가진 객체 배열이 포함된 JSON 파일")
+# --- 사이드바 ---
+st.sidebar.title('⚙️ 설정 및 제어')
 
+# 1. 유사도 임계값
+threshold = st.sidebar.slider(
+    '유사도 임계값 (Similarity Threshold)', 0.1, 0.95, st.session_state.threshold, 0.05,
+    help='이 값 이상으로 유사한 단어만 연결합니다. 높을수록 연결이 엄격해집니다.'
+)
+if threshold != st.session_state.threshold:
+    st.session_state.threshold = threshold
+    st.session_state.fig = None # 설정 변경 시 그래프 재생성 필요 알림
+    st.session_state.generate_clicked = False
+
+st.sidebar.divider()
+
+# 2. t-SNE 파라미터 (시각화 미세 조정)
+st.sidebar.header("t-SNE 파라미터 (고급)")
+perplexity = st.sidebar.slider(
+    "Perplexity", 5, 50, st.session_state.perplexity, 1,
+    help="각 점이 고려하는 이웃 수와 관련. 군집 형태에 영향."
+)
+learning_rate = st.sidebar.select_slider(
+    "Learning Rate", options=[10, 50, 100, 200, 500, 1000, 'auto'], value=st.session_state.learning_rate,
+    help="최적화 학습 속도. 군집 간 거리에 영향."
+)
+n_iter = st.sidebar.select_slider(
+    "Iterations", options=[250, 500, 1000, 2000, 5000], value=st.session_state.n_iter,
+    help="최적화 반복 횟수. 높을수록 안정적이나 오래 걸림."
+)
+# t-SNE 파라미터 변경 시 상태 업데이트 및 그래프 초기화
+if (perplexity != st.session_state.perplexity or
+    learning_rate != st.session_state.learning_rate or
+    n_iter != st.session_state.n_iter):
+    st.session_state.perplexity = perplexity
+    st.session_state.learning_rate = learning_rate
+    st.session_state.n_iter = n_iter
+    st.session_state.fig = None
+    st.session_state.generate_clicked = False
+
+st.sidebar.divider()
+
+# 3. 파일 업로드
+st.sidebar.header('📄 파일 업로드')
+uploaded_file = st.sidebar.file_uploader(
+    "JSON 파일 업로드 (형식: [{'word': '단어1'}, ...])", type=['json']
+)
 if uploaded_file is not None:
-    if st.sidebar.button('파일 업로드'):
+    with st.spinner("업로드된 파일 처리 중..."):
         new_file_id = handle_uploaded_file(uploaded_file)
         if new_file_id:
-            st.success(f"파일 '{uploaded_file.name}'이(가) 성공적으로 업로드되었습니다.")
-            st.session_state.selected_files = [new_file_id]
-            # 스크립트 재실행
-            st.experimental_rerun()
-
-# 캐시 초기화 버튼
-if st.sidebar.button('캐시 초기화'):
-    clear_cache()
-
-# 파일 선택 영역
-st.sidebar.header('데이터 파일 선택')
-
-# app.py의 핵심 수정 부분
-
-# multiselect 대신 session_state를 직접 사용하는 방식으로 변경
-if st.session_state.data_files:
-    # 파일 선택 옵션 생성
-    options = {}
-    for file_id, file_info in st.session_state.data_files.items():
-        label = f"{file_info['name']} ({file_info['word_count']}개 단어) {'[기본]' if file_info['type'] == 'default' else '[업로드됨]'}"
-        options[file_id] = label
-    
-    # 기본값 설정 (아직 선택이 없으면 첫 번째 파일 선택)
-    if not st.session_state.selected_files and options:
-        st.session_state.selected_files = [next(iter(options.keys()))]
-    
-    # 체크박스로 파일 선택 구현 - 이게 key point!
-    st.sidebar.subheader("파일 선택 (여러 개 선택 가능)")
-    
+            st.sidebar.success(f"파일 '{uploaded_file.name}' 업로드 완료!")
+            # 새로 업로드된 파일을 자동으로 선택 목록에 추가 및 선택
+            if new_file_id not in st.session_state.selected_files:
+                 st.session_state.selected_files.append(new_file_id)
+            st.rerun() # UI 즉시 갱신
+
+st.sidebar.divider()
+
+# 4. 파일 선택
+st.sidebar.header('🗂️ 데이터 파일 선택')
+current_data_files = st.session_state.get('data_files', {})
+if current_data_files:
+    st.sidebar.markdown("**사용할 파일을 선택하세요:**")
     selected_files_temp = []
-    for file_id, label in options.items():
-        # 현재 선택 상태를 기반으로 기본값 설정
+    sorted_file_ids = sorted(current_data_files.keys(), key=lambda fid: current_data_files[fid]['name'])
+
+    for file_id in sorted_file_ids:
+        if file_id not in current_data_files: continue # 안전장치
+        file_info = current_data_files[file_id]
+        file_label = f"{file_info['name']} ({file_info['word_count']} 단어)"
+        file_type_tag = "[기본]" if file_info['type'] == 'default' else "[업로드]"
+        label_full = f"{file_label} {file_type_tag}"
         is_selected = file_id in st.session_state.selected_files
-        # 각 파일에 대한 체크박스 생성
-        if st.sidebar.checkbox(label, value=is_selected, key=f"file_{file_id}"):
+
+        # 체크박스 상태 변경 감지
+        if st.sidebar.checkbox(label_full, value=is_selected, key=f"cb_{file_id}"):
             selected_files_temp.append(file_id)
-    
-    # 선택 상태 업데이트
-    st.session_state.selected_files = selected_files_temp
-    
-    # 선택된 파일 미리보기
+            # 파일 정보 확장 섹션
+            with st.sidebar.expander("파일 정보 보기", expanded=False):
+                 st.markdown(f"**샘플:** `{'`, `'.join(file_info['sample_words'])}`")
+                 if file_info['type'] == 'uploaded':
+                     if st.button('🗑️ 이 파일 삭제', key=f"del_{file_id}", help=f"'{file_info['name']}' 삭제"):
+                         if delete_file(file_id):
+                             st.rerun() # 삭제 성공 시 UI 갱신
+
+    # 선택 상태 변경 시 세션 업데이트 및 그래프 초기화
+    if sorted(selected_files_temp) != sorted(st.session_state.selected_files):
+        st.session_state.selected_files = selected_files_temp
+        st.session_state.fig = None
+        st.session_state.generate_clicked = False
+        st.rerun() # 선택 변경 시 즉시 UI 반영
+
+    st.sidebar.divider()
+
+    # 5. 그래프 생성 버튼
     if st.session_state.selected_files:
-        st.sidebar.subheader('선택된 파일 미리보기')
-        for file_id in st.session_state.selected_files:
-            file_info = st.session_state.data_files[file_id]
-            
-            col1, col2 = st.sidebar.columns([3, 1])
-            with col1:
-                st.write(f"**{file_info['name']}**")
-                st.write(f"단어 수: {file_info['word_count']}")
-                st.write(f"샘플: {', '.join(file_info['sample_words'])}")
-            
-            with col2:
-                if file_info['type'] == 'uploaded':
-                    if st.button('삭제', key=f"delete_{file_id}"):
-                        if delete_file(file_id):
-                            st.success(f"파일 '{file_info['name']}'이(가) 삭제되었습니다.")
-                            # 스크립트 재실행
-                            st.experimental_rerun()
-    
-    # 그래프 생성 버튼
-    generate_button = st.sidebar.button('그래프 생성')
+        if st.sidebar.button('📊 그래프 생성/업데이트', key='generate_button', type="primary"):
+            st.session_state.generate_clicked = True
+            # 버튼 클릭 시 자동으로 rerun 되므로 여기서는 플래그만 설정
+    else:
+        st.sidebar.warning('그래프를 생성할 파일을 1개 이상 선택해주세요.')
+
 else:
-    st.sidebar.warning('사용 가능한 데이터 파일이 없습니다. 파일을 업로드하세요.')
-    generate_button = False
-
-# 메인 콘텐츠
-if st.session_state.selected_files and (generate_button or 'fig' in st.session_state):
-    with st.spinner('그래프 생성 중...'):
-        fig = generate_graph(st.session_state.selected_files, threshold)
-        st.session_state.fig = fig
-        
-    if fig:
-        # 그래프 표시
-        st.plotly_chart(fig, use_container_width=True)
-        
-        # 선택된 파일 정보
-        file_names = [st.session_state.data_files[file_id]['name'] for file_id in st.session_state.selected_files]
-        word_counts = sum([st.session_state.data_files[file_id]['word_count'] for file_id in st.session_state.selected_files])
-        
-        # 차트 정보
-        st.info(f"""
-        **현재 그래프 정보**
-        - 데이터 파일: {', '.join(file_names)}
-        - 총 단어 수: {word_counts}개
-        - 유사도 임계값: {threshold}
-        """)
-        
+    st.sidebar.info('사용 가능한 데이터 파일이 없습니다. 파일을 업로드하거나 `data` 폴더에 JSON 파일을 추가하세요.')
+
+st.sidebar.divider()
+
+# 6. 캐시 초기화 버튼
+if st.sidebar.button('🔄 캐시 초기화', key='clear_cache_button'):
+    clear_cache()
+
+
+# --- 메인 콘텐츠 영역 ---
+st.header("📈 3D 단어 네트워크 시각화")
+
+# 그래프 표시 로직
+if st.session_state.selected_files:
+    # 그래프를 생성해야 하는 조건 확인
+    should_generate_graph = st.session_state.generate_clicked or \
+                            (st.session_state.fig is None and st.session_state.selected_files) # 선택은 했는데 아직 그래프 없을 때
+
+    if should_generate_graph and st.session_state.get('fasttext_model'): # 모델 로드 확인
+        with st.spinner('의미 기반 그래프 생성 중... 잠시만 기다려주세요.'):
+            try:
+                # generate_graph 함수 호출 (모든 파라미터 전달)
+                fig = generate_graph(
+                    st.session_state.selected_files,
+                    st.session_state.threshold,
+                    st.session_state.perplexity,
+                    st.session_state.learning_rate,
+                    st.session_state.n_iter
+                )
+                st.session_state.fig = fig # 성공 시 fig 저장
+            except Exception as e:
+                st.error(f"그래프 생성 중 심각한 오류 발생: {e}")
+                st.session_state.fig = None # 실패 시 fig 초기화
+            finally:
+                 st.session_state.generate_clicked = False # 작업 완료 후 클릭 플래그 리셋
+
+    # 생성된 그래프가 있으면 표시
+    if st.session_state.get('fig') is not None:
+        st.plotly_chart(st.session_state.fig, use_container_width=True)
+
+        # 현재 그래프 정보 표시
+        try:
+            num_nodes = len(st.session_state.fig.data[1].x) if len(st.session_state.fig.data) > 1 and hasattr(st.session_state.fig.data[1], 'x') else 0
+            num_edges = len(st.session_state.fig.data[0].x) // 3 if len(st.session_state.fig.data) > 0 and hasattr(st.session_state.fig.data[0], 'x') and st.session_state.fig.data[0].x else 0
+
+            # 사용된 파일 이름 얻기 (데이터 로드 후)
+            current_data_files = st.session_state.get('data_files', {})
+            selected_file_names = [current_data_files[fid]['name'] for fid in st.session_state.selected_files if fid in current_data_files]
+
+            st.info(f"""
+            **현재 그래프 정보**
+            - **데이터 파일:** {', '.join(selected_file_names)}
+            - **고유 단어 수 (노드):** {num_nodes} 개
+            - **연결선 수 (엣지):** {num_edges} 개 (유사도 ≥ {st.session_state.threshold:.2f})
+            """)
+        except Exception as info_e:
+            st.warning(f"그래프 정보 표시 중 오류: {info_e}")
+
         # 사용 설명
-        with st.expander("그래프 조작 방법"):
+        with st.expander("💡 그래프 조작 방법"):
             st.markdown("""
-            - **마우스 휠**: 확대/축소
-            - **마우스 드래그**: 회전
-            - **마우스 오른쪽 버튼 드래그**: 이동
-            - **단어에 마우스 오버**: 단어 이름 및 연결 수 확인
+            - **확대/축소:** 마우스 휠 스크롤
+            - **회전:** 마우스 왼쪽 버튼 누른 상태로 드래그
+            - **이동 (Pan):** 마우스 오른쪽 버튼 누른 상태로 드래그
+            - **단어 정보 확인:** 마우스 커서를 단어(마커) 위에 올리면 단어 이름과 연결 수를 볼 수 있습니다.
+            - **툴바:** 그래프 우측 상단 툴바 아이콘으로 다양한 기능(다운로드, 초기화 등) 사용 가능.
             """)
-elif not st.session_state.selected_files:
-    st.info('좌측 사이드바에서 데이터 파일을 선택한 후 "그래프 생성" 버튼을 클릭하세요.')
-
-# 정보 섹션
-with st.expander("이 시각화에 대해"):
-    st.markdown("""
-    이 도구는 다음과 같은 기술을 사용하여 한국어 단어 네트워크를 시각화합니다:
-    
-    - **문자 기반 임베딩**: 각 단어의 문자 구성을 기반으로 임베딩을 생성합니다.
-    - **t-SNE 차원 축소**: 복잡한 고차원 벡터를 3D 공간에 투영하여 의미적 관계를 시각화합니다.
-    - **코사인 유사도**: 단어 벡터 간 각도를 기반으로 의미적 유사성을 측정합니다.
-    - **Plotly 시각화**: 인터랙티브한 3D 시각화를 제공합니다.
-    
-    각 단어는 3D 공간의 점으로 표시되며, 유사도가 높은 단어들은 연결선(엣지)으로 연결됩니다. 색상은 z축 값에 따라 다르게 표시됩니다.
-    """)
-
-# JSON 파일 형식 안내
-with st.expander("JSON 파일 형식"):
-    st.markdown("""
-    업로드하는 JSON 파일은 다음 형식을 따라야 합니다:
-    ```json
-    [
-      {"word": "학교"},
-      {"word": "선생님"},
-      {"word": "친구"},
-      {"word": "숙제"},
-      ...
-    ]
-    ```
-    
-    각 항목은 "word" 필드를 가진 객체이며, 배열 안에 포함되어야 합니다.
-    """)
+    # 그래프 생성을 해야하는데 아직 안 한 경우 or 생성 실패한 경우
+    elif not should_generate_graph and st.session_state.fig is None:
+         st.info("👈 사이드바에서 '📊 그래프 생성/업데이트' 버튼을 클릭하여 시각화를 시작하세요.")
+
+# 선택된 파일이 없는 경우
+elif not st.session_state.data_files:
+     st.warning("표시할 데이터 파일이 없습니다. 파일을 업로드하거나 `data` 폴더에 유효한 JSON 파일을 추가하세요.")
+else: # 데이터 파일은 있으나 선택하지 않은 경우
+     st.info("👈 사이드바에서 분석할 데이터 파일을 선택해주세요.")
+
+
+# --- 하단 정보 섹션 ---
+st.divider()
+with st.expander("ℹ️ 이 시각화 도구에 대하여"):
+    st.markdown(f"""
+    이 도구는 다음과 같은 과정을 통해 한국어 단어 네트워크를 시각화합니다:
+
+    1.  **데이터 로딩:** 사용자가 제공한 JSON 파일에서 'word' 필드를 가진 단어 목록을 추출합니다.
+    2.  **단어 임베딩 (FastText):** 각 단어를 **사전 학습된 FastText 모델**(`{os.path.basename(FASTTEXT_MODEL_PATH)}` 사용 중)을 사용하여 고차원의 의미 벡터로 변환합니다.
+    3.  **유사도 계산:** 단어 벡터 간의 **코사인 유사도**를 계산합니다.
+    4.  **차원 축소 (t-SNE):** 고차원 벡터를 3차원으로 축소하여 시각화합니다. t-SNE 파라미터(Perplexity: {st.session_state.perplexity}, Learning Rate: {st.session_state.learning_rate}, Iterations: {st.session_state.n_iter})를 조절하여 군집 형태를 미세 조정할 수 있습니다.
+    5.  **그래프 생성 및 시각화:** 유사도가 설정된 임계값(현재: {st.session_state.threshold:.2f}) 이상인 단어들을 연결하여 3D 네트워크 그래프를 생성하고 표시합니다.
+    """)