Update app.py

app.py

@@ -12,20 +12,20 @@ from nltk.sentiment import SentimentIntensityAnalyzer
 from sklearn.cluster import KMeans
 import torch
 
-# GPU 사용 가능 시 설정
+# Set up GPU if available
 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
 
-# WBGDocTopic 초기화
+# Initialize WBGDocTopic
 clf = wbgtopic.WBGDocTopic(device=device)
 
-# NLTK 데이터 다운로드 (필요 시)
+# Download NLTK data if necessary
 try:
     nltk.download('punkt', quiet=True)
     nltk.download('vader_lexicon', quiet=True)
 except Exception as e:
-    print(f"NLTK 데이터 다운로드 에러: {e}")
+    print(f"NLTK data download error: {e}")
 
-# 샘플 텍스트
+# Sample Text
 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,8 +33,7 @@ The AI sector requires massive investments and extensive resources, including ad
 
 def safe_process(func):
     """
-    예외 발생 시 로그를 남기고 None을 반환하는 데코레이터.
-    Gradio 인터페이스가 예외로 인해 중단되지 않도록 도와줍니다.
+    Decorator to log exceptions and return None to prevent Gradio interface crashes.
     """
     def wrapper(*args, **kwargs):
         try:
@@ -47,10 +46,10 @@ def safe_process(func):
 @safe_process
 def parse_wbg_results(raw_output):
     """
-    wbgtopic.WBGDocTopic의 suggest_topics() 결과를
-    'label', 'score_mean', 'score_std' 구조의 리스트로 통일해서 반환한다.
+    Standardize the output of wbgtopic.WBGDocTopic's suggest_topics() into a list of dictionaries with keys:
+    'label', 'score_mean', and 'score_std'.
 
-    반환 구조 예시:
+    Example return structure:
     [
       {
         "label": "Agriculture",
@@ -60,30 +59,36 @@ def parse_wbg_results(raw_output):
       ...
     ]
     """
-    # 디버그: 실제 결과 구조를 확인해보세요
     print(">>> DEBUG: raw_output =", raw_output)
 
-    # 결과가 비었으면 빈 리스트 반환
+    # If raw_output is a dict (instead of a list), convert it to the expected list format.
+    if isinstance(raw_output, dict):
+        parsed_list = []
+        for k, v in raw_output.items():
+            parsed_list.append({
+                "label": k,
+                "score_mean": float(v) if v is not None else 0.0,
+                "score_std": 0.0
+            })
+        return parsed_list
+
+    # If the result is empty, return an empty list.
     if not raw_output:
         return []
 
+    # Assume raw_output is a list; get the first item.
     first_item = raw_output[0]
 
-    # (1) 이미 'label' 키가 있는 딕셔너리 형태라면
-    # 예: [{"label": "...", "score": ...}, ...] 혹은 {"label": "...", "score_mean": ...}
+    # Case 1: Already in the form of a dictionary with a 'label' key.
     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 only 'score' exists, use it as score_mean.
             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
@@ -98,17 +103,12 @@ def parse_wbg_results(raw_output):
             })
         return parsed_list
 
-    # (2) 토픽 이름: 점수 형태의 딕셔너리가 있는 경우
-    # 예: [{"Agriculture": 0.22, "Climate Change": 0.55}, ...]
+    # Case 2: Dictionary with topic names as keys and scores as values.
     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
+                merged[k] = v  # Overwrite duplicates with the last occurrence.
 
         parsed_list = []
         for label, val in merged.items():
@@ -119,17 +119,17 @@ def parse_wbg_results(raw_output):
             })
         return parsed_list
 
-    # 예상치 못한 구조인 경우
+    # If the structure is unexpected, return an empty list.
     return []
 
 @safe_process
 def analyze_text_sections(text):
     """
-    텍스트를 여러 섹션(예: 3문장씩)으로 나누고,
-    각 섹션별로 suggest_topics() 결과를 parse_wbg_results()로 파싱해 리스트로 모은다.
+    Split the text into multiple sections (e.g., every 3 sentences) and analyze topics for each section using suggest_topics().
+    Returns a list of topic lists for each section.
     """
     sentences = sent_tokenize(text)
-    # 3문장씩 묶어서 하나의 섹션을 구성
+    # Group every 3 sentences into one section.
     sections = [' '.join(sentences[i:i+3]) for i in range(0, len(sentences), 3)]
 
     section_topics = []
@@ -143,11 +143,8 @@ def analyze_text_sections(text):
 @safe_process
 def calculate_topic_correlations(topic_dicts):
     """
-    topic_dicts: [{'label': ..., 'score_mean': ..., 'score_std': ...}, ...]
-
-    주제별 score_mean만 뽑아서 상관관계를 구한다.
-    실제로는 '서로 다른 문서'들에 대한 상관을 구하는 것이 타당하나,
-    여기서는 예시로 단일 텍스트의 서로 다른 토픽들 간 점수 상관도를 계산한다.
+    Calculate correlation among topic score_means from a list of topic dictionaries.
+    Note: Ideally, correlations should be calculated across different documents, but here we use topics from a single text.
     """
     if len(topic_dicts) < 2:
         return np.array([[1.0]]), ["Insufficient topics"]
@@ -164,8 +161,8 @@ def calculate_topic_correlations(topic_dicts):
 @safe_process
 def perform_sentiment_analysis(text):
     """
-    NLTK VADER를 사용해 문장별 감성 점수를 계산한다.
-    반환값은 pandas DataFrame 형식.
+    Perform sentiment analysis on each sentence using NLTK's VADER.
+    Returns a pandas DataFrame of sentiment scores.
     """
     sia = SentimentIntensityAnalyzer()
     sents = sent_tokenize(text)
@@ -175,8 +172,8 @@ def perform_sentiment_analysis(text):
 @safe_process
 def create_topic_clusters(topic_dicts):
     """
-    score_mean, score_std 2차원으로 KMeans 클러스터링.
-    토픽 수가 3개 미만이면 trivially 0번 클러스터로 처리.
+    Perform KMeans clustering on topics based on score_mean and score_std.
+    If there are fewer than 3 topics, assign all to cluster 0.
     """
     if len(topic_dicts) < 3:
         return [0] * len(topic_dicts)
@@ -196,8 +193,8 @@ def create_topic_clusters(topic_dicts):
 @safe_process
 def create_main_charts(topic_dicts):
     """
-    바 차트와 레이더 차트를 생성.
-    'score_mean'을 0~1로 보고, 100배 하여 퍼센트로 시각화.
+    Generate a bar chart and radar chart.
+    'score_mean' is assumed to be in the range 0-1 and is converted to a percentage.
     """
     if not topic_dicts:
         return go.Figure(), go.Figure()
@@ -205,28 +202,28 @@ def create_main_charts(topic_dicts):
     labels = [t['label'] for t in topic_dicts]
     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='주제 분석 결과',
-        xaxis_title='주제',
-        yaxis_title='관련도(%)',
+        title='Topic Analysis Results',
+        xaxis_title='Topics',
+        yaxis_title='Relevance (%)',
         template='plotly_white',
         height=500,
     )
 
-    # 레이더 차트
+    # Radar chart
     radar_fig = go.Figure()
     radar_fig.add_trace(go.Scatterpolar(
         r=scores,
         theta=labels,
         fill='toself',
-        name='주제 분포'
+        name='Topic Distribution'
     ))
     radar_fig.update_layout(
-        title='주제 레이더 차트',
+        title='Topic Radar Chart',
         template='plotly_white',
         height=500,
         polar=dict(radialaxis=dict(visible=True)),
@@ -237,15 +234,13 @@ def create_main_charts(topic_dicts):
 @safe_process
 def create_correlation_heatmap(corr_matrix, labels):
     """
-    상관관계 행렬을 히트맵으로 시각화.
-    만약 데이터가 부족하면 안내 문구만 표시.
+    Visualize the correlation matrix as a heatmap.
+    If data is insufficient, display a message.
     """
     if corr_matrix.ndim == 0:
-        # 스칼라(0차원)이면 2차원 배열로 바꿔줌
         corr_matrix = np.array([[corr_matrix]])
 
     if corr_matrix.shape == (1, 1):
-        # 데이터가 부족한 경우
         fig = go.Figure()
         fig.add_annotation(text="Not enough topics for correlation", showarrow=False)
         return fig
@@ -257,7 +252,7 @@ def create_correlation_heatmap(corr_matrix, labels):
         colorscale='Viridis'
     ))
     fig.update_layout(
-        title='주제 상관관계 히트맵',
+        title='Topic Correlation Heatmap',
         height=500,
         template='plotly_white'
     )
@@ -266,8 +261,8 @@ def create_correlation_heatmap(corr_matrix, labels):
 @safe_process
 def create_topic_evolution(section_topics):
     """
-    섹션별 토픽 점수 변화를 라인 차트로 나타낸다.
-    section_topics: [[{'label':..., 'score_mean':...}, ...], [...], ...]
+    Create a line chart showing topic score evolution across different sections.
+    section_topics: List of lists containing topic dictionaries for each section.
     """
     fig = go.Figure()
     if not section_topics or len(section_topics) == 0:
@@ -276,7 +271,7 @@ def create_topic_evolution(section_topics):
     if not section_topics[0]:
         return fig
 
-    # 첫 섹션의 토픽들을 기준으로, 각 섹션마다 해당 토픽이 존재하면 점수를 추출
+    # Use topics from the first section as reference.
     for topic_dict in section_topics[0]:
         label = topic_dict['label']
         score_list = []
@@ -295,9 +290,9 @@ def create_topic_evolution(section_topics):
         ))
 
     fig.update_layout(
-        title='섹션별 주제 변화 추이',
-        xaxis_title='섹션',
-        yaxis_title='score_mean',
+        title='Section-wise Topic Evolution',
+        xaxis_title='Section',
+        yaxis_title='Score Mean',
         height=500,
         template='plotly_white'
     )
@@ -306,8 +301,8 @@ def create_topic_evolution(section_topics):
 @safe_process
 def create_confidence_gauge(topic_dicts):
     """
-    각 토픽의 신뢰도를 게이지 형태로 표시.
-    여기서는 (1 - score_std) * 100 단순 공식 사용.
+    Display each topic's confidence as a gauge.
+    Confidence is calculated using a simple formula: (1 - score_std) * 100.
     """
     if not topic_dicts:
         return go.Figure()
@@ -334,47 +329,47 @@ def create_confidence_gauge(topic_dicts):
 @spaces.GPU()
 def process_all_analysis(text):
     """
-    전체 텍스트에 대한 토픽 분석, 섹션 분석, 상관관계, 감성분석, 클러스터링 등을 수행한 뒤
-    JSON 결과와 Plotly 차트들을 반환한다.
+    Perform comprehensive analysis on the input text, including topic analysis, section analysis,
+    correlation, sentiment analysis, clustering, and generate corresponding JSON results and Plotly charts.
     """
     try:
-        # 1) 전체 텍스트 대상 토픽 분석
+        # 1) Analyze topics for the entire text.
         raw_results = clf.suggest_topics(text)
         all_topics = parse_wbg_results(raw_results)
 
-        # 2) score_mean 기준 내림차순 정렬 후 상위 5개
+        # 2) Sort topics by score_mean in descending order and take the top 5.
         sorted_topics = sorted(all_topics, key=lambda x: x['score_mean'], reverse=True)
         top_topics = sorted_topics[:5]
 
-        # 3) 섹션 별 분석
+        # 3) Analyze topics by sections.
         section_topics = analyze_text_sections(text)
 
-        # 4) 추가 분석(상관관계, 감성분석, 클러스터)
+        # 4) Additional analyses (correlation, sentiment, clustering).
         corr_matrix, corr_labels = calculate_topic_correlations(all_topics)
         sentiments_df = perform_sentiment_analysis(text)
         clusters = create_topic_clusters(all_topics)
 
-        # 5) 차트 생성
+        # 5) Generate charts.
         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) JSON 형태로 묶어서 반환(문자열 키만 사용)
+        # 6) Return results as JSON and charts.
         results = {
-            "top_topics": top_topics,                         # 상위 5개 토픽
-            "clusters": clusters,                             # 클러스터 결과
-            "sentiments": sentiments_df.to_dict(orient="records")  # 감성 분석
+            "top_topics": top_topics,                           # Top 5 topics.
+            "clusters": clusters,                               # Cluster results.
+            "sentiments": sentiments_df.to_dict(orient="records") # Sentiment analysis results.
         }
 
         return (
-            results,          # JSON output
-            bar_chart,        # plot1
-            radar_chart,      # plot2
-            heatmap,          # plot3
-            evolution_chart,  # plot4
-            gauge_chart,      # plot5
-            go.Figure()       # plot6 (필요 시 감성분석 그래프 사용)
+            results,          # JSON output.
+            bar_chart,        # Plot 1: Topic Distribution (Bar Chart).
+            radar_chart,      # Plot 2: Radar Chart.
+            heatmap,          # Plot 3: Correlation Heatmap.
+            evolution_chart,  # Plot 4: Section Topic Evolution.
+            gauge_chart,      # Plot 5: Confidence Gauge.
+            go.Figure()       # Plot 6: (Placeholder for Sentiment Analysis Chart).
         )
 
     except Exception as e:
@@ -394,38 +389,38 @@ def process_all_analysis(text):
 #                Gradio UI Definition               #
 ######################################################
 
-with gr.Blocks(title="고급 문서 주제 분석기") as demo:
-    gr.Markdown("## 고급 문서 주제 분석기")
+with gr.Blocks(title="Advanced Document Topic Analyzer") as demo:
+    gr.Markdown("## Advanced Document Topic Analyzer")
     gr.Markdown(
-        "텍스트를 입력한 뒤, **분석 시작** 버튼을 눌러주세요. "
-        "주요 토픽 분석, 상관관계, 신뢰도 게이지, 감성분석 결과 등을 확인할 수 있습니다."
+        "Enter the text below and click **Start Analysis**. "
+        "The tool will analyze key topics, correlations, confidence gauges, sentiment analysis, and more."
     )
 
     with gr.Row():
         text_input = gr.Textbox(
             value=SAMPLE_TEXT,
-            label="분석할 텍스트 입력",
+            label="Enter Text for Analysis",
             lines=8
         )
     with gr.Row():
-        submit_btn = gr.Button("분석 시작", variant="primary")
+        submit_btn = gr.Button("Start Analysis", variant="primary")
 
     with gr.Tabs():
-        with gr.TabItem("주요 분석"):
+        with gr.TabItem("Main Analysis"):
             with gr.Row():
-                plot1 = gr.Plot(label="주제 분포(Bar Chart)")
-                plot2 = gr.Plot(label="레이더 차트")
-        with gr.TabItem("상세 분석"):
+                plot1 = gr.Plot(label="Topic Distribution (Bar Chart)")
+                plot2 = gr.Plot(label="Radar Chart")
+        with gr.TabItem("Detailed Analysis"):
             with gr.Row():
-                plot3 = gr.Plot(label="상관관계 히트맵")
-                plot4 = gr.Plot(label="섹션별 토픽 변화")
-        with gr.TabItem("신뢰도 분석"):
-            plot5 = gr.Plot(label="신뢰도 게이지")
-        with gr.TabItem("감성 분석"):
-            plot6 = gr.Plot(label="감성분석 결과")
+                plot3 = gr.Plot(label="Correlation Heatmap")
+                plot4 = gr.Plot(label="Section Topic Evolution")
+        with gr.TabItem("Confidence Analysis"):
+            plot5 = gr.Plot(label="Confidence Gauge")
+        with gr.TabItem("Sentiment Analysis"):
+            plot6 = gr.Plot(label="Sentiment Analysis Result")
 
     with gr.Row():
-        output_json = gr.JSON(label="상세 분석 결과(JSON)")
+        output_json = gr.JSON(label="Detailed Analysis Result (JSON)")
 
     submit_btn.click(
         fn=process_all_analysis,
@@ -438,6 +433,6 @@ if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=False,  # 공개 링크 필요 시 True
+        share=False,  # Set to True if you need a public shareable link.
         debug=True
     )