Update app.py

app.py

@@ -12,20 +12,20 @@ from nltk.sentiment import SentimentIntensityAnalyzer
 from sklearn.cluster import KMeans
 import torch
 
-# Set GPU if available
+# GPU 사용 가능 시 설정
 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
 
-# Initialize WBGDocTopic
+# WBGDocTopic 초기화
 clf = wbgtopic.WBGDocTopic(device=device)
 
-# Download NLTK data if needed
+# NLTK 데이터 다운로드 (필요 시)
 try:
     nltk.download('punkt', quiet=True)
     nltk.download('vader_lexicon', quiet=True)
 except Exception as e:
-    print(f"NLTK data download error: {e}")
+    print(f"NLTK 데이터 다운로드 에러: {e}")
 
-# Sample text for demonstration
+# 샘플 텍스트
 SAMPLE_TEXT = """
 The three reportedly discussed the Stargate Project, a large-scale AI initiative led by OpenAI, SoftBank, and U.S. software giant Oracle. The project aims to invest $500 billion over the next four years in building new AI infrastructure in the U.S. The U.S. government has shown a strong commitment to the initiative, with President Donald Trump personally announcing it at the White House the day after his inauguration last month. If Samsung participates, the project will lead to a Korea-U.S.-Japan AI alliance.
 The AI sector requires massive investments and extensive resources, including advanced models, high-performance AI chips to power the models, and large-scale data centers to operate them. Nvidia and TSMC currently dominate the AI sector, but a partnership between Samsung, SoftBank, and OpenAI could pave the way for a competitive alternative.
@@ -33,9 +33,8 @@ The AI sector requires massive investments and extensive resources, including ad
 
 def safe_process(func):
     """
-    A decorator that catches and logs exceptions inside a function,
-    returning None if an error occurs. This helps ensure that
-    the Gradio interface does not crash from unexpected exceptions.
+    예외 발생 시 로그를 남기고 None을 반환하는 데코레이터.
+    Gradio 인터페이스가 예외로 인해 중단되지 않도록 도와줍니다.
     """
     def wrapper(*args, **kwargs):
         try:
@@ -48,44 +47,89 @@ def safe_process(func):
 @safe_process
 def parse_wbg_results(raw_output):
     """
-    Convert the raw output from WBGDocTopic into a list of dictionaries with
-    'label', 'score_mean', and 'score_std'. Adjust logic according to the
-    actual structure of raw_output.
+    wbgtopic.WBGDocTopic의 suggest_topics() 결과를
+    'label', 'score_mean', 'score_std' 구조의 리스트로 통일해서 반환한다.
+
+    반환 구조 예시:
+    [
+      {
+        "label": "Agriculture",
+        "score_mean": 0.32,
+        "score_std": 0.05
+      },
+      ...
+    ]
     """
+    # 디버그: 실제 결과 구조를 확인해보세요
+    print(">>> DEBUG: raw_output =", raw_output)
+
+    # 결과가 비었으면 빈 리스트 반환
     if not raw_output:
         return []
 
-    # Example logic: If raw_output is something like:
-    # [ { "Innovation and Entrepreneurship": 0.74, "Digital Development": 0.65, ... } ]
-    # We'll parse it accordingly.
     first_item = raw_output[0]
 
-    # If the first item is already a dict with a 'label' key, it might already be in the right format
-    if isinstance(first_item, dict) and "label" in first_item:
-        return raw_output
+    # (1) 이미 'label' 키가 있는 딕셔너리 형태라면
+    # 예: [{"label": "...", "score": ...}, ...] 혹은 {"label": "...", "score_mean": ...}
+    if isinstance(first_item, dict) and ("label" in first_item):
+        parsed_list = []
+        for item in raw_output:
+            label = item.get("label", "")
+            # score_mean / score_std가 이미 있으면 사용
+            # 없으면 score 등에서 추론
+            score_mean = item.get("score_mean", None)
+            score_std = item.get("score_std", None)
+
+            # 예: score만 있는 경우
+            if score_mean is None and "score" in item:
+                # 점수가 0~1 범위인지 0~100 범위인지 확인 필요
+                # 우선 그대로 float 처리
+                score_mean = float(item["score"])
+            if score_mean is None:
+                score_mean = 0.0
+
+            if score_std is None:
+                score_std = 0.0
 
-    # If it's a dict containing topic -> score
+            parsed_list.append({
+                "label": label,
+                "score_mean": float(score_mean),
+                "score_std": float(score_std)
+            })
+        return parsed_list
+
+    # (2) 토픽 이름: 점수 형태의 딕셔너리가 있는 경우
+    # 예: [{"Agriculture": 0.22, "Climate Change": 0.55}, ...]
     if isinstance(first_item, dict):
+        # raw_output가 여러 dict를 담고 있을 수 있으므로, 하나로 합치거나
+        # 혹은 첫 번째 dict만 파싱할지 결정해야 함.
+        # 일단 여기서는 합치는 방식으로 시연:
+        merged = {}
+        for d in raw_output:
+            for k, v in d.items():
+                # 키 중복 시 마지막 값으로 overwrite
+                merged[k] = v
+
         parsed_list = []
-        for label, val in first_item.items():
+        for label, val in merged.items():
             parsed_list.append({
                 "label": label,
                 "score_mean": float(val),
-                "score_std": 0.0  # If std is not provided, default to 0
+                "score_std": 0.0
             })
         return parsed_list
 
+    # 예상치 못한 구조인 경우
     return []
 
 @safe_process
 def analyze_text_sections(text):
     """
-    Splits the text into sections and calls clf.suggest_topics for each section.
-    Returns a list of topic lists, where each element is the parsed WBG result
-    for that section.
+    텍스트를 여러 섹션(예: 3문장씩)으로 나누고,
+    각 섹션별로 suggest_topics() 결과를 parse_wbg_results()로 파싱해 리스트로 모은다.
     """
     sentences = sent_tokenize(text)
-    # Example: group every 3 sentences into one section
+    # 3문장씩 묶어서 하나의 섹션을 구성
     sections = [' '.join(sentences[i:i+3]) for i in range(0, len(sentences), 3)]
 
     section_topics = []
@@ -99,10 +143,11 @@ def analyze_text_sections(text):
 @safe_process
 def calculate_topic_correlations(topic_dicts):
     """
-    Calculates correlation between topics based on 'score_mean'.
-    This is usually a single-dimensional correlation across different topics,
-    which can be conceptually limited, but shown here as an example.
-    Returns (corr_matrix, labels).
+    topic_dicts: [{'label': ..., 'score_mean': ..., 'score_std': ...}, ...]
+
+    주제별 score_mean만 뽑아서 상관관계를 구한다.
+    실제로는 '서로 다른 문서'들에 대한 상관을 구하는 것이 타당하나,
+    여기서는 예시로 단일 텍스트의 서로 다른 토픽들 간 점수 상관도를 계산한다.
     """
     if len(topic_dicts) < 2:
         return np.array([[1.0]]), ["Insufficient topics"]
@@ -119,9 +164,8 @@ def calculate_topic_correlations(topic_dicts):
 @safe_process
 def perform_sentiment_analysis(text):
     """
-    Uses NLTK's VADER sentiment analyzer to produce sentiment scores
-    (neg, neu, pos, compound) for each sentence in the text.
-    Returns a pandas DataFrame of results.
+    NLTK VADER를 사용해 문장별 감성 점수를 계산한다.
+    반환값은 pandas DataFrame 형식.
     """
     sia = SentimentIntensityAnalyzer()
     sents = sent_tokenize(text)
@@ -131,8 +175,8 @@ def perform_sentiment_analysis(text):
 @safe_process
 def create_topic_clusters(topic_dicts):
     """
-    Applies a KMeans clustering on (score_mean, score_std).
-    If there are fewer than 3 topics, returns trivial cluster assignments.
+    score_mean, score_std 2차원으로 KMeans 클러스터링.
+    토픽 수가 3개 미만이면 trivially 0번 클러스터로 처리.
     """
     if len(topic_dicts) < 3:
         return [0] * len(topic_dicts)
@@ -152,37 +196,37 @@ def create_topic_clusters(topic_dicts):
 @safe_process
 def create_main_charts(topic_dicts):
     """
-    Creates a bar chart and a radar chart for the given list of topics.
-    Uses 'score_mean' as the base score.
+    바 차트와 레이더 차트를 생성.
+    'score_mean'을 0~1로 보고, 100배 하여 퍼센트로 시각화.
     """
     if not topic_dicts:
         return go.Figure(), go.Figure()
 
     labels = [t['label'] for t in topic_dicts]
-    scores = [t['score_mean'] * 100 for t in topic_dicts]  # scale to %
+    scores = [t['score_mean'] * 100 for t in topic_dicts]
 
-    # Bar chart
+    # 바 차트
     bar_fig = go.Figure(
         data=[go.Bar(x=labels, y=scores, marker_color='rgb(55, 83, 109)')]
     )
     bar_fig.update_layout(
-        title='Topic Analysis Results',
-        xaxis_title='Topics',
-        yaxis_title='Relevance (%)',
+        title='주제 분석 결과',
+        xaxis_title='주제',
+        yaxis_title='관련도(%)',
         template='plotly_white',
         height=500,
     )
 
-    # Radar chart
+    # 레이더 차트
     radar_fig = go.Figure()
     radar_fig.add_trace(go.Scatterpolar(
         r=scores,
         theta=labels,
         fill='toself',
-        name='Topic Distribution'
+        name='주제 분포'
     ))
     radar_fig.update_layout(
-        title='Topic Radar Chart',
+        title='주제 레이더 차트',
         template='plotly_white',
         height=500,
         polar=dict(radialaxis=dict(visible=True)),
@@ -193,15 +237,15 @@ def create_main_charts(topic_dicts):
 @safe_process
 def create_correlation_heatmap(corr_matrix, labels):
     """
-    Creates a heatmap figure of the provided correlation matrix.
-    If there's insufficient data, shows a placeholder message.
+    상관관계 행렬을 히트맵으로 시각화.
+    만약 데이터가 부족하면 안내 문구만 표시.
     """
     if corr_matrix.ndim == 0:
-        # It's a scalar => shape ()
+        # 스칼라(0차원)이면 2차원 배열로 바꿔줌
         corr_matrix = np.array([[corr_matrix]])
 
     if corr_matrix.shape == (1, 1):
-        # Not enough data for correlation
+        # 데이터가 부족한 경우
         fig = go.Figure()
         fig.add_annotation(text="Not enough topics for correlation", showarrow=False)
         return fig
@@ -213,7 +257,7 @@ def create_correlation_heatmap(corr_matrix, labels):
         colorscale='Viridis'
     ))
     fig.update_layout(
-        title='Topic Correlation Heatmap',
+        title='주제 상관관계 히트맵',
         height=500,
         template='plotly_white'
     )
@@ -222,9 +266,8 @@ def create_correlation_heatmap(corr_matrix, labels):
 @safe_process
 def create_topic_evolution(section_topics):
     """
-    Plots topic evolution across sections.
-    section_topics: list of lists, where each inner list
-    is a list of dicts [{'label':..., 'score_mean':...}, ...]
+    섹션별 토픽 점수 변화를 라인 차트로 나타낸다.
+    section_topics: [[{'label':..., 'score_mean':...}, ...], [...], ...]
     """
     fig = go.Figure()
     if not section_topics or len(section_topics) == 0:
@@ -233,7 +276,7 @@ def create_topic_evolution(section_topics):
     if not section_topics[0]:
         return fig
 
-    # For each topic in the first section, track the score across all sections
+    # 첫 섹션의 토픽들을 기준으로, 각 섹션마다 해당 토픽이 존재하면 점수를 추출
     for topic_dict in section_topics[0]:
         label = topic_dict['label']
         score_list = []
@@ -252,9 +295,9 @@ def create_topic_evolution(section_topics):
         ))
 
     fig.update_layout(
-        title='Topic Evolution Across Sections',
-        xaxis_title='Section',
-        yaxis_title='Score Mean',
+        title='섹션별 주제 변화 추이',
+        xaxis_title='섹션',
+        yaxis_title='score_mean',
         height=500,
         template='plotly_white'
     )
@@ -263,8 +306,8 @@ def create_topic_evolution(section_topics):
 @safe_process
 def create_confidence_gauge(topic_dicts):
     """
-    Creates individual gauge indicators for each topic's confidence.
-    A simple heuristic: confidence = (1 - score_std) * 100.
+    각 토픽의 신뢰도를 게이지 형태로 표시.
+    여기서는 (1 - score_std) * 100 단순 공식 사용.
     """
     if not topic_dicts:
         return go.Figure()
@@ -273,7 +316,6 @@ def create_confidence_gauge(topic_dicts):
     num_topics = len(topic_dicts)
 
     for i, t in enumerate(topic_dicts):
-        # If score_std not present, default to 0 => confidence = 100%
         conf_val = 100.0 * (1.0 - t.get("score_std", 0.0))
         fig.add_trace(go.Indicator(
             mode="gauge+number",
@@ -292,48 +334,47 @@ def create_confidence_gauge(topic_dicts):
 @spaces.GPU()
 def process_all_analysis(text):
     """
-    Main function that calls all analysis steps and returns
-    structured JSON plus various Plotly figures.
+    전체 텍스트에 대한 토픽 분석, 섹션 분석, 상관관계, 감성분석, 클러스터링 등을 수행한 뒤
+    JSON 결과와 Plotly 차트들을 반환한다.
     """
     try:
-        # 1) Suggest topics for the entire text
+        # 1) 전체 텍스트 대상 토픽 분석
         raw_results = clf.suggest_topics(text)
         all_topics = parse_wbg_results(raw_results)
 
-        # 2) Sort by 'score_mean' descending to get top 5
+        # 2) score_mean 기준 내림차순 정렬 후 상위 5개
         sorted_topics = sorted(all_topics, key=lambda x: x['score_mean'], reverse=True)
         top_topics = sorted_topics[:5]
 
-        # 3) Analyze by sections
+        # 3) 섹션 별 분석
         section_topics = analyze_text_sections(text)
 
-        # 4) Extra analyses
+        # 4) 추가 분석(상관관계, 감성분석, 클러스터)
         corr_matrix, corr_labels = calculate_topic_correlations(all_topics)
         sentiments_df = perform_sentiment_analysis(text)
         clusters = create_topic_clusters(all_topics)
 
-        # 5) Build charts
+        # 5) 차트 생성
         bar_chart, radar_chart = create_main_charts(top_topics)
         heatmap = create_correlation_heatmap(corr_matrix, corr_labels)
         evolution_chart = create_topic_evolution(section_topics)
         gauge_chart = create_confidence_gauge(top_topics)
 
-        # 6) Prepare JSON output (ensure valid JSON with string keys)
+        # 6) JSON 형태로 묶어서 반환(문자열 키만 사용)
         results = {
-            "top_topics": top_topics,                # list of dict
-            "clusters": clusters,                   # list of ints
-            "sentiments": sentiments_df.to_dict(orient="records")
+            "top_topics": top_topics,                         # 상위 5개 토픽
+            "clusters": clusters,                             # 클러스터 결과
+            "sentiments": sentiments_df.to_dict(orient="records")  # 감성 분석
         }
 
-        # Return JSON + Figures
         return (
-            results,        # JSON output
-            bar_chart,      # plot1
-            radar_chart,    # plot2
-            heatmap,        # plot3
-            evolution_chart,# plot4
-            gauge_chart,    # plot5
-            go.Figure()     # plot6 (placeholder for sentiment plot, if desired)
+            results,          # JSON output
+            bar_chart,        # plot1
+            radar_chart,      # plot2
+            heatmap,          # plot3
+            evolution_chart,  # plot4
+            gauge_chart,      # plot5
+            go.Figure()       # plot6 (필요 시 감성분석 그래프 사용)
         )
 
     except Exception as e:
@@ -353,38 +394,38 @@ def process_all_analysis(text):
 #                Gradio UI Definition               #
 ######################################################
 
-with gr.Blocks(title="Advanced Document Topic Analyzer") as demo:
-    gr.Markdown("## 📝 Advanced Document Topic Analyzer")
+with gr.Blocks(title="고급 문서 주제 분석기") as demo:
+    gr.Markdown("## 고급 문서 주제 분석기")
     gr.Markdown(
-        "Enter text, then click 'Start Analysis' to see topic analysis, correlation, "
-        "confidence gauges, sentiment, and more."
+        "텍스트를 입력한 뒤, **분석 시작** 버튼을 눌러주세요. "
+        "주요 토픽 분석, 상관관계, 신뢰도 게이지, 감성분석 결과 등을 확인할 수 있습니다."
     )
 
     with gr.Row():
         text_input = gr.Textbox(
             value=SAMPLE_TEXT,
-            label="Text to Analyze",
+            label="분석할 텍스트 입력",
             lines=8
         )
     with gr.Row():
-        submit_btn = gr.Button("Start Analysis", variant="primary")
+        submit_btn = gr.Button("분석 시작", variant="primary")
 
     with gr.Tabs():
-        with gr.TabItem("Main Analysis"):
+        with gr.TabItem("주요 분석"):
             with gr.Row():
-                plot1 = gr.Plot(label="Topic Distribution")
-                plot2 = gr.Plot(label="Radar Chart")
-        with gr.TabItem("Detailed Analysis"):
+                plot1 = gr.Plot(label="주제 분포(Bar Chart)")
+                plot2 = gr.Plot(label="레이더 차트")
+        with gr.TabItem("상세 분석"):
             with gr.Row():
-                plot3 = gr.Plot(label="Correlation Heatmap")
-                plot4 = gr.Plot(label="Topic Evolution")
-        with gr.TabItem("Confidence Analysis"):
-            plot5 = gr.Plot(label="Confidence Gauge")
-        with gr.TabItem("Sentiment Analysis"):
-            plot6 = gr.Plot(label="Sentiment Results")
+                plot3 = gr.Plot(label="상관관계 히트맵")
+                plot4 = gr.Plot(label="섹션별 토픽 변화")
+        with gr.TabItem("신뢰도 분석"):
+            plot5 = gr.Plot(label="신뢰도 게이지")
+        with gr.TabItem("감성 분석"):
+            plot6 = gr.Plot(label="감성분석 결과")
 
     with gr.Row():
-        output_json = gr.JSON(label="Detailed Analysis Output")
+        output_json = gr.JSON(label="상세 분석 결과(JSON)")
 
     submit_btn.click(
         fn=process_all_analysis,
@@ -397,6 +438,6 @@ if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=False,  # Set True if you want a public share link
+        share=False,  # 공개 링크 필요 시 True
         debug=True
     )