Update app.py

app.py

@@ -12,20 +12,31 @@ from nltk.sentiment import SentimentIntensityAnalyzer
 from sklearn.cluster import KMeans
 import torch
 
+# Set GPU if available
 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
 
 # Initialize WBGDocTopic
 clf = wbgtopic.WBGDocTopic(device=device)
 
+# Download NLTK data if needed
 try:
     nltk.download('punkt', quiet=True)
     nltk.download('vader_lexicon', quiet=True)
-except:
-    pass
+except Exception as e:
+    print(f"NLTK data download error: {e}")
 
-SAMPLE_TEXT = """Your sample text here ..."""
+# 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.
+"""
 
 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.
+    """
     def wrapper(*args, **kwargs):
         try:
             return func(*args, **kwargs)
@@ -34,176 +45,144 @@ def safe_process(func):
             return None
     return wrapper
 
-
-################################################################
-#            1) Convert Raw Results into a Consistent Format    #
-################################################################
-
 @safe_process
 def parse_wbg_results(raw_output):
     """
-    Example: raw_output might be something like:
-    [
-      { 'Innovation and Entrepreneurship': 0.32,
-        'Digital Development': 0.27,
-        ...}
-    ]
-    or it might be [ [ {...}, {...} ] ]
-    
-    Adjust logic so we end up with a list of dicts:
-    [
-      {'label': 'Innovation and Entrepreneurship', 'score_mean': 0.32, 'score_std': 0.0},
-      {'label': 'Digital Development', 'score_mean': 0.27, 'score_std': 0.0},
-      ...
-    ]
+    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.
     """
     if not raw_output:
         return []
-    
-    # If the library returns a list with a single dictionary:
-    # raw_output[0] might be a dict of {topic: score}
-    # or it might be a list of dicts with 'label'/'score_mean' keys
+
+    # 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 it's already a list of dicts with 'label', 'score_mean', etc.
-    if isinstance(first_item, dict) and 'label' in first_item:
-        # Possibly we already have the correct format
+
+    # 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
-    
-    # If it's a dict of {topic_label: numeric_score}
+
+    # If it's a dict containing topic -> score
     if isinstance(first_item, dict):
-        # Then let's convert it
         parsed_list = []
         for label, val in first_item.items():
             parsed_list.append({
-                'label': label,
-                'score_mean': float(val),
-                'score_std': 0.0  # If no std is given, default 0
+                "label": label,
+                "score_mean": float(val),
+                "score_std": 0.0  # If std is not provided, default to 0
             })
         return parsed_list
-    
-    # If it’s something else, handle it
-    return []
 
-
-################################################################
-#               2) Section-based Analysis                      #
-################################################################
+    return []
 
 @safe_process
 def analyze_text_sections(text):
     """
-    Splits text into sections, calls clf.suggest_topics on each,
-    and returns a list-of-lists:
-    section_topics = [
-       [ {'label':'...', 'score_mean':...}, {...} ],
-       [ {'label':'...', 'score_mean':...}, {...} ],
-       ...
-    ]
+    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.
     """
     sentences = sent_tokenize(text)
-    # e.g. group 3 sentences per section
+    # Example: group every 3 sentences into one section
     sections = [' '.join(sentences[i:i+3]) for i in range(0, len(sentences), 3)]
-    
+
     section_topics = []
     for section in sections:
         raw_sec = clf.suggest_topics(section)
         parsed_sec = parse_wbg_results(raw_sec)
         section_topics.append(parsed_sec)
-    
-    return section_topics
 
-
-################################################################
-#   3) Basic Summaries (Correlation, Sentiment, Clusters etc.) #
-################################################################
+    return section_topics
 
 @safe_process
 def calculate_topic_correlations(topic_dicts):
     """
-    If we only want a single dimension correlation (like score_mean),
-    we can do a simple correlation across different topics.
-    But typically you'd want multiple texts or some multi-dimensional approach.
+    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).
     """
     if len(topic_dicts) < 2:
-        # Not enough to do correlation
         return np.array([[1.0]]), ["Insufficient topics"]
-    
+
     labels = [d['label'] for d in topic_dicts]
-    scores = [d['score_mean'] for d in topic_dicts]  # single dimension
-    
+    scores = [d['score_mean'] for d in topic_dicts]
+
     if len(scores) < 2:
         return np.array([[1.0]]), ["Insufficient topics"]
-    
+
     corr_matrix = np.corrcoef(scores)
     return corr_matrix, labels
 
-
 @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.
+    """
     sia = SentimentIntensityAnalyzer()
     sents = sent_tokenize(text)
     results = [sia.polarity_scores(s) for s in sents]
     return pd.DataFrame(results)
 
-
 @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.
+    """
     if len(topic_dicts) < 3:
-        return [0]*len(topic_dicts)  # trivial cluster
-    
-    # Must have 'score_mean' and 'score_std' or something else
+        return [0] * len(topic_dicts)
+
     X = []
     for t in topic_dicts:
         X.append([t['score_mean'], t.get('score_std', 0.0)])
-    
+
     X = np.array(X)
     if X.shape[0] < 3:
-        return [0]*X.shape[0]
-    
+        return [0] * X.shape[0]
+
     kmeans = KMeans(n_clusters=min(3, X.shape[0]), random_state=42)
     clusters = kmeans.fit_predict(X)
-    return clusters.tolist()  # safe to JSON-encode
-
-
-################################################################
-#       4) Charts (Bar, Radar, Correlation Heatmap, etc.)      #
-################################################################
+    return clusters.tolist()
 
 @safe_process
 def create_main_charts(topic_dicts):
     """
-    Expects a list of dicts with keys: 'label', 'score_mean', ...
-    We'll just use 'score_mean' (or a scaled version).
+    Creates a bar chart and a radar chart for the given list of topics.
+    Uses 'score_mean' as the base score.
     """
     if not topic_dicts:
         return go.Figure(), go.Figure()
-    
-    # Bar chart
+
     labels = [t['label'] for t in topic_dicts]
-    scores = [t['score_mean']*100 for t in topic_dicts]  # convert to %
-    
+    scores = [t['score_mean'] * 100 for t in topic_dicts]  # scale to %
+
+    # 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)),
@@ -211,19 +190,22 @@ def create_main_charts(topic_dicts):
     )
     return bar_fig, radar_fig
 
-
 @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 ()
         corr_matrix = np.array([[corr_matrix]])
-    
-    if corr_matrix.shape == (1,1):
-        # Usually means not enough data
+
+    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
-    
+
     fig = go.Figure(data=go.Heatmap(
         z=corr_matrix,
         x=labels,
@@ -231,78 +213,75 @@ def create_correlation_heatmap(corr_matrix, labels):
         colorscale='Viridis'
     ))
     fig.update_layout(
-        title='주제 간 상관관계',
+        title='Topic Correlation Heatmap',
         height=500,
         template='plotly_white'
     )
     return fig
 
-
 @safe_process
 def create_topic_evolution(section_topics):
     """
-    section_topics: list of [ {label:..., score_mean:...}, ...]
-    one element per section
+    Plots topic evolution across sections.
+    section_topics: list of lists, where each inner list
+    is a list of dicts [{'label':..., 'score_mean':...}, ...]
     """
     fig = go.Figure()
     if not section_topics or len(section_topics) == 0:
         return fig
-    
-    # Take the first section’s list as reference
+
     if not section_topics[0]:
         return fig
-    
-    # For each topic in the first section, gather its evolution
+
+    # 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 = []
         for sec_list in section_topics:
-            # find matching label
             match = next((d for d in sec_list if d['label'] == label), None)
             if match:
                 score_list.append(match['score_mean'])
             else:
                 score_list.append(0.0)
-        
+
         fig.add_trace(go.Scatter(
             x=list(range(len(section_topics))),
             y=score_list,
             name=label,
             mode='lines+markers'
         ))
-    
+
     fig.update_layout(
-        title='주제 변화 추이',
-        xaxis_title='섹션',
-        yaxis_title='score_mean',
+        title='Topic Evolution Across Sections',
+        xaxis_title='Section',
+        yaxis_title='Score Mean',
         height=500,
         template='plotly_white'
     )
     return fig
 
-
 @safe_process
 def create_confidence_gauge(topic_dicts):
     """
-    If your data doesn’t actually have a separate confidence measure,
-    you may skip or adapt. For example, you might define confidence
-    = (1 - score_std)*100
+    Creates individual gauge indicators for each topic's confidence.
+    A simple heuristic: confidence = (1 - score_std) * 100.
     """
     if not topic_dicts:
         return go.Figure()
-    
+
     fig = go.Figure()
     num_topics = len(topic_dicts)
-    
+
     for i, t in enumerate(topic_dicts):
-        confidence_val = 100.0*(1.0 - t.get('score_std', 0.0))  # an example
+        # 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",
-            value=confidence_val,
+            value=conf_val,
             title={'text': t['label']},
             domain={'row': 0, 'column': i}
         ))
-    
+
     fig.update_layout(
         grid={'rows': 1, 'columns': num_topics},
         height=400,
@@ -310,45 +289,43 @@ def create_confidence_gauge(topic_dicts):
     )
     return fig
 
-
-################################################################
-#   5) Putting Everything into `process_all_analysis`          #
-################################################################
-
 @spaces.GPU()
 def process_all_analysis(text):
+    """
+    Main function that calls all analysis steps and returns
+    structured JSON plus various Plotly figures.
+    """
     try:
-        # 1) Suggest topics on the entire text
+        # 1) Suggest topics for the entire text
         raw_results = clf.suggest_topics(text)
-        all_topics = parse_wbg_results(raw_results)  # keep full list of dicts
-        
-        # 2) Top 5 (if you want to highlight them)
-        #    Sort by score_mean descending
+        all_topics = parse_wbg_results(raw_results)
+
+        # 2) Sort by 'score_mean' descending to get top 5
         sorted_topics = sorted(all_topics, key=lambda x: x['score_mean'], reverse=True)
         top_topics = sorted_topics[:5]
-        
-        # 3) Section-based
-        section_topics = analyze_text_sections(text)  # list of lists
-        
+
+        # 3) Analyze by sections
+        section_topics = analyze_text_sections(text)
+
         # 4) Extra analyses
         corr_matrix, corr_labels = calculate_topic_correlations(all_topics)
         sentiments_df = perform_sentiment_analysis(text)
         clusters = create_topic_clusters(all_topics)
-        
+
         # 5) Build charts
-        bar_chart, radar_chart = create_main_charts(top_topics)  # show top 5 on bar
+        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 output for the JSON field
-        # Make sure everything is JSON-serializable with string keys
+
+        # 6) Prepare JSON output (ensure valid JSON with string keys)
         results = {
-            "top_topics": top_topics,  # list of dict
-            "clusters": clusters,      # list of ints
-            "sentiments": sentiments_df.to_dict(orient="records"), 
+            "top_topics": top_topics,                # list of dict
+            "clusters": clusters,                   # list of ints
+            "sentiments": sentiments_df.to_dict(orient="records")
         }
-        
+
+        # Return JSON + Figures
         return (
             results,        # JSON output
             bar_chart,      # plot1
@@ -356,9 +333,9 @@ def process_all_analysis(text):
             heatmap,        # plot3
             evolution_chart,# plot4
             gauge_chart,    # plot5
-            go.Figure()     # plot6 (placeholder for sentiment plot, or skip)
+            go.Figure()     # plot6 (placeholder for sentiment plot, if desired)
         )
-    
+
     except Exception as e:
         print(f"Analysis error: {str(e)}")
         empty_fig = go.Figure()
@@ -372,40 +349,43 @@ def process_all_analysis(text):
             empty_fig
         )
 
+######################################################
+#                Gradio UI Definition               #
+######################################################
 
-################################################################
-#   6) Gradio UI                                               #
-################################################################
+with gr.Blocks(title="Advanced Document Topic Analyzer") as demo:
+    gr.Markdown("## 📝 Advanced Document Topic Analyzer")
+    gr.Markdown(
+        "Enter text, then click 'Start Analysis' to see topic analysis, correlation, "
+        "confidence gauges, sentiment, and more."
+    )
 
-with gr.Blocks(title="고급 문서 주제 분석기") as demo:
-    gr.Markdown("## 📊 고급 문서 주제 분석기")
-    
     with gr.Row():
         text_input = gr.Textbox(
             value=SAMPLE_TEXT,
-            label="분석할 텍스트",
+            label="Text to Analyze",
             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="주제 분포")
-                plot2 = gr.Plot(label="레이더 차트")
-        with gr.TabItem("상세 분석"):
+                plot1 = gr.Plot(label="Topic Distribution")
+                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="Topic Evolution")
+        with gr.TabItem("Confidence Analysis"):
+            plot5 = gr.Plot(label="Confidence Gauge")
+        with gr.TabItem("Sentiment Analysis"):
+            plot6 = gr.Plot(label="Sentiment Results")
+
     with gr.Row():
-        output_json = gr.JSON(label="상세 분석 결과")
-    
+        output_json = gr.JSON(label="Detailed Analysis Output")
+
     submit_btn.click(
         fn=process_all_analysis,
         inputs=[text_input],
@@ -417,6 +397,6 @@ if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=False,  
+        share=False,  # Set True if you want a public share link
         debug=True
     )