Update app.py

app.py

@@ -4,36 +4,26 @@ import spaces
 import wbgtopic
 import plotly.graph_objects as go
 import plotly.express as px
-import plotly.figure_factory as ff
-import nltk
 import numpy as np
 import pandas as pd
-from collections import Counter
-from scipy import stats
-import torch
-from wordcloud import WordCloud
-from topic_translator import translate_topics
+import nltk
 from nltk.tokenize import sent_tokenize, word_tokenize
 from nltk.sentiment import SentimentIntensityAnalyzer
 from sklearn.cluster import KMeans
+import torch
 
-# GPU 설정
 device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
 
-# NLTK 필요 데이터 다운로드
+# Initialize WBGDocTopic
+clf = wbgtopic.WBGDocTopic(device=device)
+
 try:
     nltk.download('punkt', quiet=True)
     nltk.download('vader_lexicon', quiet=True)
-except Exception as e:
-    print(f"NLTK 데이터 다운로드 중 오류 발생: {e}")
+except:
+    pass
 
-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.
-"""
-
-# WBGDocTopic 초기화 시 device 지정
-clf = wbgtopic.WBGDocTopic(device=device)
+SAMPLE_TEXT = """Your sample text here ..."""
 
 def safe_process(func):
     def wrapper(*args, **kwargs):
@@ -44,144 +34,196 @@ 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},
+      ...
+    ]
+    """
+    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
+    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
+        return raw_output
+    
+    # If it's a dict of {topic_label: numeric_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
+            })
+        return parsed_list
+    
+    # If it’s something else, handle it
+    return []
+
+
+################################################################
+#               2) Section-based Analysis                      #
+################################################################
+
 @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':...}, {...} ],
+       ...
+    ]
+    """
     sentences = sent_tokenize(text)
+    # e.g. group 3 sentences per section
     sections = [' '.join(sentences[i:i+3]) for i in range(0, len(sentences), 3)]
-    section_topics = []
     
+    section_topics = []
     for section in sections:
-        topics = clf.suggest_topics(section)[0]
-        section_topics.append(topics)
+        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.) #
+################################################################
+
 @safe_process
-def calculate_topic_correlations(topics):
-    try:
-        if not topics or len(topics) < 1:
-            return np.array([[1]]), ['No topics']
-            
-        topic_scores = {}
-        for topic in topics:
-            if 'score_mean' in topic:
-                topic_scores[topic['label']] = topic['score_mean']
-            elif 'score' in topic:  # score로도 확인
-                topic_scores[topic['label']] = topic['score'] / 100.0
-        
-        if len(topic_scores) < 1:
-            return np.array([[1]]), ['No valid scores']
-            
-        correlation_matrix = np.corrcoef(list(topic_scores.values()))
-        return correlation_matrix, list(topic_scores.keys())
-    except Exception as e:
-        print(f"Correlation calculation error: {e}")
-        return np.array([[1]]), ['Error']
+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.
+    """
+    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
+    
+    if len(scores) < 2:
+        return np.array([[1.0]]), ["Insufficient topics"]
+    
+    corr_matrix = np.corrcoef(scores)
+    return corr_matrix, labels
 
-@spaces.GPU()
-def process_all_analysis(text):
-    try:
-        # 기본 주제 분석
-        raw_results = clf.suggest_topics(text)
-        topics = process_results(raw_results)
-        
-        # 추가 분석
-        section_topics = analyze_text_sections(text)
-        corr_matrix, labels = calculate_topic_correlations(topics)
-        sentiments = perform_sentiment_analysis(text)
-        clusters = create_topic_clusters(topics)
-        
-        # 차트 생성
-        bar_chart, radar_chart = create_main_charts(topics)
-        heatmap = create_correlation_heatmap(corr_matrix, labels)
-        evolution_chart = create_topic_evolution(section_topics)
-        gauge_chart = create_confidence_gauge(topics)
-        
-        results = {
-            'topics': topics,
-            'bar_chart': bar_chart,
-            'radar_chart': radar_chart,
-            'heatmap': heatmap,
-            'evolution': evolution_chart,
-            'gauge': gauge_chart,
-            'sentiments': sentiments.to_dict() if sentiments is not None else {},
-            'clusters': clusters.tolist() if clusters is not None else []
-        }
-        
-        # 개별 결과 반환
-        return (
-            results,  # JSON output
-            bar_chart,  # plot1
-            radar_chart,  # plot2
-            heatmap,  # plot3
-            evolution_chart,  # plot4
-            gauge_chart,  # plot5
-            go.Figure()  # plot6 (빈 감성 분석 차트)
-        )
-    except Exception as e:
-        print(f"Analysis error: {str(e)}")
-        empty_fig = go.Figure()
-        return (
-            {'error': str(e), 'topics': []},
-            empty_fig,
-            empty_fig,
-            empty_fig,
-            empty_fig,
-            empty_fig,
-            empty_fig
-        )
 
 @safe_process
 def perform_sentiment_analysis(text):
     sia = SentimentIntensityAnalyzer()
-    sentences = sent_tokenize(text)
-    sentiments = [sia.polarity_scores(sent) for sent in sentences]
-    return pd.DataFrame(sentiments)
+    sents = sent_tokenize(text)
+    results = [sia.polarity_scores(s) for s in sents]
+    return pd.DataFrame(results)
+
 
 @safe_process
-def create_topic_clusters(topics):
-    if len(topics) < 3:
-        return np.zeros(len(topics))
+def create_topic_clusters(topic_dicts):
+    if len(topic_dicts) < 3:
+        return [0]*len(topic_dicts)  # trivial cluster
+    
+    # Must have 'score_mean' and 'score_std' or something else
+    X = []
+    for t in topic_dicts:
+        X.append([t['score_mean'], t.get('score_std', 0.0)])
     
-    X = np.array([[t['score_mean'], t['score_std']] for t in topics])
-    kmeans = KMeans(n_clusters=min(3, len(topics)), random_state=42)
+    X = np.array(X)
+    if X.shape[0] < 3:
+        return [0]*X.shape[0]
+    
+    kmeans = KMeans(n_clusters=min(3, X.shape[0]), random_state=42)
     clusters = kmeans.fit_predict(X)
-    return clusters
+    return clusters.tolist()  # safe to JSON-encode
+
+
+################################################################
+#       4) Charts (Bar, Radar, Correlation Heatmap, etc.)      #
+################################################################
 
 @safe_process
-def create_main_charts(topics):
-    bar_fig = go.Figure()
-    bar_fig.add_trace(go.Bar(
-        x=[t['label'] for t in topics],
-        y=[t['score'] for t in topics],
-        name='관련도',
-        marker_color='rgb(55, 83, 109)'
-    ))
+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).
+    """
+    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 %
+    
+    bar_fig = go.Figure(
+        data=[go.Bar(x=labels, y=scores, marker_color='rgb(55, 83, 109)')]
+    )
     bar_fig.update_layout(
         title='주제 분석 결과',
-        height=500,
         xaxis_title='주제',
         yaxis_title='관련도 (%)',
-        template='plotly_white'
+        template='plotly_white',
+        height=500,
     )
     
+    # Radar chart
     radar_fig = go.Figure()
     radar_fig.add_trace(go.Scatterpolar(
-        r=[t['score'] for t in topics],
-        theta=[t['label'] for t in topics],
+        r=scores,
+        theta=labels,
         fill='toself',
         name='주제 분포'
     ))
     radar_fig.update_layout(
         title='주제 레이더 차트',
+        template='plotly_white',
         height=500,
-        template='plotly_white'
+        polar=dict(radialaxis=dict(visible=True)),
+        showlegend=False
     )
-    
     return bar_fig, radar_fig
 
+
 @safe_process
 def create_correlation_heatmap(corr_matrix, labels):
+    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
+        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,
@@ -195,85 +237,155 @@ def create_correlation_heatmap(corr_matrix, labels):
     )
     return fig
 
+
 @safe_process
 def create_topic_evolution(section_topics):
-    if not section_topics or len(section_topics) == 0:
-        return go.Figure()
-
+    """
+    section_topics: list of [ {label:..., score_mean:...}, ...]
+    one element per section
+    """
     fig = go.Figure()
-    for topic in section_topics[0]:
-        try:
-            topic_scores = [topics[topic['label']]['score_mean'] 
-                          for topics in section_topics]
-            fig.add_trace(go.Scatter(
-                x=list(range(len(section_topics))),
-                y=topic_scores,
-                name=topic['label'],
-                mode='lines+markers'
-            ))
-        except Exception as e:
-            print(f"Error processing topic {topic['label']}: {e}")
-            continue
+    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 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='관련도',
+        yaxis_title='score_mean',
         height=500,
         template='plotly_white'
     )
     return fig
 
+
 @safe_process
-def create_confidence_gauge(topics):
+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
+    """
+    if not topic_dicts:
+        return go.Figure()
+    
     fig = go.Figure()
-    for i, topic in enumerate(topics):
+    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
         fig.add_trace(go.Indicator(
             mode="gauge+number",
-            value=topic['confidence'],
-            title={'text': topic['label']},
-            domain={'row': 0, 'column': i, 'x': [i/len(topics), (i+1)/len(topics)]}
+            value=confidence_val,
+            title={'text': t['label']},
+            domain={'row': 0, 'column': i}
         ))
+    
     fig.update_layout(
-        grid={'rows': 1, 'columns': len(topics)},
+        grid={'rows': 1, 'columns': num_topics},
         height=400,
         template='plotly_white'
     )
     return fig
 
-@safe_process
-def process_results(results):
-    if not results or not results[0]:
-        return []
-    
-    topics = results[0]
-    top_topics = sorted(topics, key=lambda x: x['score_mean'], reverse=True)[:5]
-    
-    formatted_topics = []
-    for topic in top_topics:
-        formatted_topic = {
-            'label': translate_topics.get(topic['label'], topic['label']),
-            'score': round(topic['score_mean'] * 100, 1),
-            'confidence': round((1 - topic['score_std']) * 100, 1)
+
+################################################################
+#   5) Putting Everything into `process_all_analysis`          #
+################################################################
+
+@spaces.GPU()
+def process_all_analysis(text):
+    try:
+        # 1) Suggest topics on 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
+        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
+        
+        # 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
+        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
+        results = {
+            "top_topics": top_topics,  # list of dict
+            "clusters": clusters,      # list of ints
+            "sentiments": sentiments_df.to_dict(orient="records"), 
         }
-        formatted_topics.append(formatted_topic)
+        
+        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, or skip)
+        )
     
-    return formatted_topics
+    except Exception as e:
+        print(f"Analysis error: {str(e)}")
+        empty_fig = go.Figure()
+        return (
+            {"error": str(e), "topics": []},
+            empty_fig,
+            empty_fig,
+            empty_fig,
+            empty_fig,
+            empty_fig,
+            empty_fig
+        )
 
 
+################################################################
+#   6) Gradio UI                                               #
+################################################################
 
 with gr.Blocks(title="고급 문서 주제 분석기") as demo:
     gr.Markdown("## 📊 고급 문서 주제 분석기")
-    gr.Markdown("문서를 입력하면 다양한 분석 결과를 시각화하여 보여줍니다.")
     
     with gr.Row():
-        text = gr.Textbox(
+        text_input = gr.Textbox(
             value=SAMPLE_TEXT,
             label="분석할 텍스트",
-            placeholder="여기에 분석할 텍스트를 입력하세요",
             lines=8
         )
-    
     with gr.Row():
         submit_btn = gr.Button("분석 시작", variant="primary")
     
@@ -282,25 +394,22 @@ with gr.Blocks(title="고급 문서 주제 분석기") as demo:
             with gr.Row():
                 plot1 = gr.Plot(label="주제 분포")
                 plot2 = gr.Plot(label="레이더 차트")
-        
         with gr.TabItem("상세 분석"):
             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="감성 분석 결과")
-            
+    
     with gr.Row():
-        output = gr.JSON(label="상세 분석 결과")
+        output_json = gr.JSON(label="상세 분석 결과")
     
     submit_btn.click(
         fn=process_all_analysis,
-        inputs=[text],
-        outputs=[output, plot1, plot2, plot3, plot4, plot5, plot6]
+        inputs=[text_input],
+        outputs=[output_json, plot1, plot2, plot3, plot4, plot5, plot6]
     )
 
 if __name__ == "__main__":
@@ -308,6 +417,6 @@ if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=True,  # 공개 링크 생성을 위해 True로 설정
+        share=False,  
         debug=True
-    )
+    )