Upload app.py

src/app.py

@@ -164,14 +164,80 @@ def load_data(data_dir_str: str):
             cities_df, countries_df, fields_df, intents_df, journals_df)
 
 
-# ── KG + Enriched 데이터 (별도 지연 로드) ─────────────────────
+# ── KG 데이터: DuckDB 방식으로 분리 로드 ─────────────────────
+#   kg_nodes  : pandas 전체 로드 (~160MB 파일, 메모리 허용 범위)
+#   kg_edges  : DuckDB로 필요한 노드의 엣지만 쿼리 (전체 로드 안 함)
+#   enriched  : DuckDB로 집계 통계만 쿼리 (전체 로드 안 함)
+
 @st.cache_data(show_spinner=False)
-def load_kg_data(data_dir_str: str):
+def load_kg_nodes(data_dir_str: str) -> pd.DataFrame:
+    """kg_nodes 전체 로드 (3.4M rows, ~160MB 파일)"""
     d = None if HF_REPO_ID else Path(data_dir_str)
-    kg_nodes = _read("kg_nodes.parquet", d)
-    kg_edges = _read("kg_edges.parquet", d)
-    enriched = _read("citation_events_enriched.parquet", d)
-    return kg_nodes, kg_edges, enriched
+    return _read("kg_nodes.parquet", d)
+
+
+@st.cache_data(show_spinner=False)
+def get_parquet_path(filename: str, data_dir_str: str) -> str:
+    """파일 경로 반환 (HF면 로컬 캐시에 다운로드 후 경로 반환)"""
+    if HF_REPO_ID:
+        return _hf_download(filename)
+    # DuckDB용: 역슬래시 → 슬래시 변환
+    return str(Path(data_dir_str) / filename).replace("\\", "/")
+
+
+@st.cache_data(show_spinner=False)
+def query_kg_edges_for_node(node_id: str, kg_edges_path: str, max_edges: int = 80) -> pd.DataFrame:
+    """DuckDB: 특정 노드의 엣지만 parquet에서 바로 쿼리 (전체 로드 없음)"""
+    import duckdb
+    safe_path = kg_edges_path.replace("\\", "/")
+    safe_node = node_id.replace("'", "''")
+    q = f"""
+    SELECT source, target, edge_type
+    FROM read_parquet('{safe_path}')
+    WHERE source = '{safe_node}' OR target = '{safe_node}'
+    LIMIT {int(max_edges)}
+    """
+    return duckdb.execute(q).df()
+
+
+@st.cache_data(show_spinner=False)
+def query_enriched_stats(enriched_path: str):
+    """DuckDB: enriched 전체 로드 없이 집계 통계만 쿼리"""
+    import duckdb
+    safe_path = enriched_path.replace("\\", "/")
+
+    sem_df = duckdb.execute(f"""
+        SELECT has_semantic_evidence, COUNT(*) AS count
+        FROM read_parquet('{safe_path}')
+        GROUP BY has_semantic_evidence
+    """).df()
+
+    field_df = duckdb.execute(f"""
+        SELECT field_folder AS field,
+               AVG(CAST(has_semantic_evidence AS INTEGER)) AS sem_ratio,
+               COUNT(*) AS event_count
+        FROM read_parquet('{safe_path}')
+        GROUP BY field_folder
+        ORDER BY sem_ratio DESC
+        LIMIT 20
+    """).df()
+
+    return sem_df, field_df
+
+
+@st.cache_data(show_spinner=False)
+def query_explorer_edges(node_id: str, kg_edges_path: str, max_edges: int = 60) -> pd.DataFrame:
+    """DuckDB: KG Explorer용 임의 노드 엣지 쿼리"""
+    import duckdb
+    safe_path = kg_edges_path.replace("\\", "/")
+    safe_node = node_id.replace("'", "''")
+    q = f"""
+    SELECT source, target, edge_type
+    FROM read_parquet('{safe_path}')
+    WHERE source = '{safe_node}' OR target = '{safe_node}'
+    LIMIT {int(max_edges)}
+    """
+    return duckdb.execute(q).df()
 
 
 # ── 헬퍼 ───────────────────────────────────────────────────────
@@ -486,39 +552,49 @@ with tab_ontology:
     components.html(pyvis_ontology(), height=820, scrolling=True)
 
 
-# ═══ 4. KNOWLEDGE GRAPH (실제 KG 데이터) ═════════════════════════
+# ═══ 4. KNOWLEDGE GRAPH (실제 KG 데이터, DuckDB) ════════════════
 with tab_kg:
     st.subheader("Knowledge Graph — Selected Seed Paper")
-    st.caption("kg_nodes + kg_edges 전체 데이터에서 선택된 seed paper의 1-hop 서브그래프")
-    st.info("아래 버튼을 눌러 KG 데이터를 로드하세요 (최초 1회, 이후 캐시됨)")
+    st.caption("kg_nodes + kg_edges에서 선택된 seed paper의 1-hop 서브그래프 (DuckDB 부분 쿼리)")
+    st.info("아래 버튼을 눌러 KG 데이터를 로드하세요. kg_nodes만 전체 로드, kg_edges는 필요한 부분만 쿼리합니다.")
+
+    max_edges_kg = st.slider("Max edges", 20, 150, 80, key="kg_max_edges")
 
     if st.button("KG 데이터 로드", key="kg_load"):
-        with st.spinner("kg_nodes / kg_edges / enriched 로딩 중 ..."):
+        with st.spinner("kg_nodes 로딩 + kg_edges 경로 준비 중..."):
             st.session_state["kg_loaded"] = True
 
     if st.session_state.get("kg_loaded"):
         try:
-            kg_nodes, kg_edges, enriched = load_kg_data(data_dir_val)
+            with st.spinner("kg_nodes 로딩 중..."):
+                kg_nodes = load_kg_nodes(data_dir_val)
+
             seed_doi = selected_seed["doi"]
             if not seed_doi:
                 st.warning("선택된 seed paper의 DOI가 없어 KG 조회가 불가합니다.")
             else:
-                nodes_sub, edges_sub = get_kg_subgraph(seed_doi, kg_nodes, kg_edges)
-                if nodes_sub is None:
-                    st.warning(f"KG에서 노드를 찾을 수 없습니다. (DOI: {seed_doi})")
+                node_id = f"seed:{seed_doi}"
+
+                with st.spinner("kg_edges 쿼리 중 (DuckDB)..."):
+                    kg_edges_path = get_parquet_path("kg_edges.parquet", data_dir_val)
+                    edges_sub = query_kg_edges_for_node(node_id, kg_edges_path, max_edges_kg)
+
+                if edges_sub.empty:
+                    st.warning(f"KG에서 해당 노드의 엣지를 찾을 수 없습니다. (node_id: {node_id})")
                 else:
-                    # 통계
+                    all_node_ids = set(edges_sub["source"].tolist()) | set(edges_sub["target"].tolist())
+                    nodes_sub = kg_nodes[kg_nodes["node_id"].isin(all_node_ids)]
+
                     c1, c2, c3 = st.columns(3)
                     c1.metric("Nodes", fmt_num(len(nodes_sub)))
                     c2.metric("Edges", fmt_num(len(edges_sub)))
                     c3.metric("Node types", fmt_num(nodes_sub["node_type"].nunique()))
 
                     type_counts = nodes_sub["node_type"].value_counts().reset_index()
-                    type_counts.columns = ["node_type","count"]
+                    type_counts.columns = ["node_type", "count"]
                     st.plotly_chart(
                         px.bar(type_counts, x="node_type", y="count",
-                               color="node_type",
-                               color_discrete_map=NODE_TYPE_COLORS,
+                               color="node_type", color_discrete_map=NODE_TYPE_COLORS,
                                title="Node Type Distribution")
                         .update_layout(showlegend=False, xaxis_title="", yaxis_title="Count"),
                         use_container_width=True)
@@ -532,18 +608,21 @@ with tab_kg:
 # ═══ 5. KG EXPLORER ═════════════════════════════════════════════
 with tab_kg_exp:
     st.subheader("KG Explorer")
-    st.caption("kg_nodes 전체를 탐색하고 임의 노드의 연결 관계를 시각화합니다.")
-    st.info("아래 버튼을 눌러 KG 데이터를 로드하세요 (최초 1회, 이후 캐시됨)")
+    st.caption("kg_nodes를 탐색하고 임의 노드의 연결 관계를 시각화합니다. kg_edges는 DuckDB로 필요한 부분만 쿼리합니다.")
+    st.info("아래 버튼을 눌러 KG 데이터를 로드하세요. kg_nodes만 전체 로드되고, kg_edges/enriched는 DuckDB로 쿼리합니다.")
 
     if st.button("KG 데이터 로드", key="kg_exp_load"):
-        with st.spinner("로딩 중..."):
+        with st.spinner("kg_nodes 로딩 중..."):
             st.session_state["kg_loaded"] = True
 
     if st.session_state.get("kg_loaded"):
         try:
-            kg_nodes, kg_edges, enriched = load_kg_data(data_dir_val)
+            with st.spinner("kg_nodes 로딩 중..."):
+                kg_nodes = load_kg_nodes(data_dir_val)
+                kg_edges_path   = get_parquet_path("kg_edges.parquet", data_dir_val)
+                enriched_path   = get_parquet_path("citation_events_enriched.parquet", data_dir_val)
 
-            # ── 전체 노드 타입 분포
+            # ── 전체 노드 타입 분포 (kg_nodes만으로 계산)
             col_a, col_b = st.columns([1,2])
             with col_a:
                 st.subheader("Node Type Counts")
@@ -551,9 +630,14 @@ with tab_kg_exp:
                 nt.columns = ["node_type","count"]
                 st.dataframe(nt, use_container_width=True, hide_index=True)
 
+                # Edge type 집계: DuckDB로 빠르게 계산
                 st.subheader("Edge Type Counts")
-                et = kg_edges["edge_type"].value_counts().reset_index()
-                et.columns = ["edge_type","count"]
+                import duckdb
+                et = duckdb.execute(f"""
+                    SELECT edge_type, COUNT(*) AS count
+                    FROM read_parquet('{kg_edges_path}')
+                    GROUP BY edge_type ORDER BY count DESC
+                """).df()
                 st.dataframe(et, use_container_width=True, hide_index=True)
 
             with col_b:
@@ -584,8 +668,7 @@ with tab_kg_exp:
                     st.warning("검색 결과가 없습니다.")
                 else:
                     sel_node_id = st.selectbox(
-                        "Select node",
-                        node_options,
+                        "Select node", node_options,
                         format_func=lambda nid: sample.loc[sample["node_id"]==nid,"label"].iloc[0][:60],
                     )
                     sel_node_info = sample[sample["node_id"]==sel_node_id].iloc[0]
@@ -596,12 +679,14 @@ with tab_kg_exp:
                     st.markdown(f"**Cited by**: {fmt_num(sel_node_info.get('citedby_count',''))}")
 
                     max_e = st.slider("Max edges shown", 20, 150, 60, key="kg_exp_max")
-
                     if st.button("Show ego network", key="kg_exp_show"):
-                        exp_nodes, exp_edges = get_explorer_subgraph(sel_node_id, kg_nodes, kg_edges, max_e)
-                        if exp_nodes is None:
+                        with st.spinner("DuckDB로 엣지 쿼리 중..."):
+                            exp_edges = query_explorer_edges(sel_node_id, kg_edges_path, max_e)
+                        if exp_edges.empty:
                             st.warning("연결된 엣지가 없습니다.")
                         else:
+                            all_ids = set(exp_edges["source"].tolist()) | set(exp_edges["target"].tolist())
+                            exp_nodes = kg_nodes[kg_nodes["node_id"].isin(all_ids)]
                             st.session_state["exp_nodes"] = exp_nodes
                             st.session_state["exp_edges"] = exp_edges
 
@@ -615,34 +700,32 @@ with tab_kg_exp:
                 else:
                     st.info("왼쪽에서 노드를 선택하고 'Show ego network'를 클릭하세요.")
 
-            # ── Enriched 인사이트
+            # ── Enriched 인사이트 (DuckDB 집계만)
             st.markdown("---")
             st.subheader("Enriched Citation Insights")
-            st.caption("citation_events_enriched: 의미적 증거(semantic evidence) 분석")
-            if "has_semantic_evidence" in enriched.columns:
-                sem = enriched["has_semantic_evidence"].value_counts().reset_index()
-                sem.columns = ["has_semantic_evidence","count"]
-                sem["label"] = sem["has_semantic_evidence"].map({True:"With evidence", False:"Without evidence"})
-                st.plotly_chart(
-                    px.pie(sem, names="label", values="count",
-                           title="Semantic Evidence Coverage (all citation events)")
-                    .update_layout(legend_title=""),
-                    use_container_width=True)
-
-                # 분야별 semantic evidence 비율
-                if "field_folder" in enriched.columns:
-                    field_sem = (enriched.groupby("field_folder")["has_semantic_evidence"]
-                                 .mean().reset_index()
-                                 .rename(columns={"has_semantic_evidence":"sem_ratio","field_folder":"field"})
-                                 .sort_values("sem_ratio", ascending=False).head(20))
+            st.caption("citation_events_enriched: DuckDB로 집계 통계만 쿼리 (전체 로드 없음)")
+            with st.spinner("Enriched 통계 쿼리 중 (DuckDB)..."):
+                sem_df, field_df = query_enriched_stats(enriched_path)
+
+            if not sem_df.empty:
+                sem_df["label"] = sem_df["has_semantic_evidence"].map(
+                    {True:"With evidence", False:"Without evidence",
+                     1:"With evidence", 0:"Without evidence"})
+                col_s1, col_s2 = st.columns(2)
+                with col_s1:
                     st.plotly_chart(
-                        px.bar(field_sem, x="field", y="sem_ratio",
-                               title="Semantic Evidence Rate by Field",
-                               labels={"sem_ratio":"Evidence Rate","field":"Field"})
-                        .update_layout(xaxis_tickangle=-40),
+                        px.pie(sem_df, names="label", values="count",
+                               title="Semantic Evidence Coverage")
+                        .update_layout(legend_title=""),
                         use_container_width=True)
-            else:
-                st.info("has_semantic_evidence 컬럼이 없습니다.")
+                with col_s2:
+                    if not field_df.empty:
+                        st.plotly_chart(
+                            px.bar(field_df, x="field", y="sem_ratio",
+                                   title="Semantic Evidence Rate by Field",
+                                   labels={"sem_ratio":"Evidence Rate","field":"Field"})
+                            .update_layout(xaxis_tickangle=-40),
+                            use_container_width=True)
 
         except Exception as e:
             st.error(str(e))