windpacer/ExperionCrawler
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
15c17522c8e02d6e9b66a9827ac88e4b0c5dd8ef
ExperionCrawler/P&ID_병렬LLM_아키텍처_개선안_v2-코딩.md

920 lines
29 KiB
Markdown
Raw Blame History

# P&ID 도면 파싱 병렬 LLM 아키텍처 개선안 v2 - 구현 가이드
## 1. 개요
이 문서는 `P&ID_병렬LLM_아키텍처_개선안_v2.md`의 개선안을 현재 프로젝트(`ExperionCrawler`)에 맞춰 **실제 구현 가능한 코드**로 정리한 문서입니다.
### 1.1 현재 프로젝트 구조
| 계층 | 파일 | 역할 |
|------|------|------|
| **C# Application Layer** | [`src/Core/Application/Services/PidGraphService.cs`](src/Core/Application/Services/PidGraphService.cs:1) | MCP 서버 호출 및 결과 처리 |
| **C# Controller** | [`src/Web/Controllers/PidGraphController.cs`](src/Web/Controllers/PidGraphController.cs:1) | HTTP API 엔드포인트 |
| **MCP Server (Python)** | [`mcp-server/server.py`](mcp-server/server.py:1) | FastMCP 기반 서버 |
| **MCP Pipeline** | [`mcp-server/pipeline/extractor.py`](mcp-server/pipeline/extractor.py:1) | Phase 1: 기하학적 추출 |
| **MCP Pipeline** | [`mcp-server/pipeline/topology.py`](mcp-server/pipeline/topology.py:1) | Phase 2: 위상 빌더 |
| **MCP Pipeline** | [`mcp-server/pipeline/mapper.py`](mcp-server/pipeline/mapper.py:1) | Phase 3: 지능형 매핑 |
| **MCP Pipeline** | [`mcp-server/pipeline/analyzer.py`](mcp-server/pipeline/analyzer.py:1) | Phase 4: 영향도 분석 |
### 1.2 기존 문제점 (P&ID_병목현상_분석_보고서.md)
| 단계 | 문제점 | 심각도 | 현재 상태 |
|------|--------|--------|-----------|
| Phase 1 | ezdxf로 28,000개 엔티티 처리 | 0.58초 (양호) | ✅ 해결됨 |
| Phase 2 | O(n²) 노드 병합 | timeout (심각) | ⚠️ R-tree 도입 필요 |
| Phase 3 | 순차적 LLM API 호출 | 예측 불가능한 지연 | ⚠️ 병렬 실행 필요 |
---
## 2. 개선안 요약
### 2.1 Phase 1: 기하학적 추출 (ezdxf) - **변경 없음**
```python
# mcp-server/pipeline/extractor.py (현재 그대로 사용)
class PidGeometricExtractor:
def __init__(self, file_path: str):
self.doc = ezdxf.readfile(file_path)
self.msp = self.doc.modelspace()
def extract_and_save(self, output_path: str):
results = []
for entity in self.msp:
bbox_obj = self.get_bbox(entity)
# ... 추출 로직
return results
```
**특징**:
- LINE (20,868개, 72.4%): 기하학적 추출만으로 충분 (LLM 불필요)
- TEXT (3,562개, 12.4%): LLM 매핑 필요
- 기타 (3,589개): LLM 매핑 필요
### 2.2 Phase 2: 위상 빌더 (공간 인덱스 도입) - **개선 필요**
**문제**: `_merge_nodes()` 메서드의 O(n²) 복잡도로 timeout 발생
**해결책**: R-tree 공간 인덱스 도입 → O(n log n)으로 개선
```python
# mcp-server/pipeline/topology.py (개선안)
from rtree import index # 추가
class PidTopologyBuilder:
def __init__(self, geometric_data: List[Dict[str, Any]], ...):
self.data = geometric_data
self.G = nx.DiGraph()
def build_graph(self):
# 1. 공간 인덱스 생성 (R-tree)
self._build_spatial_index()
# 2. 노드 병합 (O(n log n))
self._merge_nodes_spatial()
# 3. 태그-설비 연결
self._link_tags_to_equipment()
# 4. 배관 연결
self._link_pipes()
def _build_spatial_index(self):
"""R-tree 공간 인덱스 생성"""
p = index.Property()
self.idx = index.Index(properties=p)
for i, item in enumerate(self.data):
bbox = item['bbox']
self.idx.insert(i, (
bbox['min_x'], bbox['min_y'],
bbox['max_x'], bbox['max_y']
))
def _merge_nodes_spatial(self):
"""공간 인덱스를 사용한 병합 (O(n log n))"""
merge_threshold = 2.0
merged = []
visited = set()
for i, item in enumerate(self.data):
if i in visited:
continue
bbox = item['bbox']
# 인접 노드만 검색 (R-tree 사용)
neighbors = list(self.idx.intersection((
bbox['min_x'] - merge_threshold,
bbox['min_y'] - merge_threshold,
bbox['max_x'] + merge_threshold,
bbox['max_y'] + merge_threshold
)))
# ... 병합 로직
```
### 2.3 Phase 3: 병렬 LLM 매핑 (test_dxf_extract_pid*.py 구조 도입)
**문제**: 현재 `pid_intelligent_mapper.py`는 비동기로 순차적 LLM 호출
**해결책**: `test_dxf_extract_pid*.py`의 병렬 처리 구조 도입
```python
# test_dxf_extract_pid1.py, pid2.py, pid3.py의 공통 구조
chunks = [
{
'name': 'Field Instruments - Sensors',
'system': 'Extract sensor tags only...',
'user': 'Extract ALL tags of FT, FIT, LT, PT...'
},
{
'name': 'Field Instruments - Valves',
'system': 'Extract valve tags only...',
'user': 'Extract ALL tags of FCV, TCV, LCV...'
},
{
'name': 'System Tags',
'system': 'Extract system tags only...',
'user': 'Extract ALL tags of LI, PI, TI...'
}
]
```
**핵심 발견**:
- **청크 단위 분할**: 태그 유형별로 프롬프트를 분리
- **독립된 프로세스 실행**: 각 청크를 별도의 Python 프로그램으로 실행
- **vLLM GPU 자원 최대화**: 각 프로세스가 별도의 GPU에 할당됨
---
## 3. 구현 계획
### 3.1 Phase 2: R-tree 공간 인덱스 도입
#### 3.1.1 의존성 추가
```bash
# mcp-server/pyproject.toml
[project.dependencies]
rtree = "^1.3.0"
```
#### 3.1.2 topology.py 개선
```python
# mcp-server/pipeline/topology.py (개선안)
import networkx as nx
from shapely.geometry import box, Point, LineString
from rtree import index # 추가
import json
from typing import List, Dict, Any, Optional, Tuple
class PidTopologyBuilder:
def __init__(self, geometric_data: List[Dict[str, Any]], ...):
self.data = geometric_data
self.all_tags = all_extracted_tags if all_extracted_tags else []
self.config = config if config else {'dist_threshold': 50.0, 'tag_threshold': 100.0, 'merge_threshold': 2.0}
self.G = nx.DiGraph()
def build_graph(self):
# 1. 공간 인덱스 생성 (R-tree)
self._build_spatial_index()
# 2. 노드 병합 (O(n log n))
self.merged_data = self._merge_nodes_spatial()
# 3. 노드 추가
for item in self.merged_data:
bbox_vals = item['bbox']
bbox_geom = box(bbox_vals['min_x'], bbox_vals['min_y'], bbox_vals['max_x'], bbox_vals['max_y'])
self.G.add_node(item['entity_id'],
type=item['entity_type'],
bbox=bbox_geom,
value=item.get('clean_value'),
layer=item.get('layer'))
# 4. 태그-설비 연결
self._link_tags_to_equipment()
# 5. 배관 연결
self._link_pipes()
def _build_spatial_index(self):
"""R-tree 공간 인덱스 생성"""
p = index.Property()
self.idx = index.Index(properties=p)
for i, item in enumerate(self.data):
bbox = item['bbox']
self.idx.insert(i, (
bbox['min_x'], bbox['min_y'],
bbox['max_x'], bbox['max_y']
))
def _merge_nodes_spatial(self):
"""공간 인덱스를 사용한 병합 (O(n log n))"""
merge_threshold = self.config.get('merge_threshold', 2.0)
merged = []
visited = set()
for i, item in enumerate(self.data):
if i in visited:
continue
bbox = item['bbox']
# 인접 노드만 검색 (R-tree 사용)
neighbors = list(self.idx.intersection((
bbox['min_x'] - merge_threshold,
bbox['min_y'] - merge_threshold,
bbox['max_x'] + merge_threshold,
bbox['max_y'] + merge_threshold
)))
# 병합 로직 (가장 큰 엔티티 기준)
merged_item = item.copy()
for j in neighbors:
if j != i and j not in visited:
neighbor_item = self.data[j]
# BBox 병합
merged_item['bbox']['min_x'] = min(merged_item['bbox']['min_x'], neighbor_item['bbox']['min_x'])
merged_item['bbox']['min_y'] = min(merged_item['bbox']['min_y'], neighbor_item['bbox']['min_y'])
merged_item['bbox']['max_x'] = max(merged_item['bbox']['max_x'], neighbor_item['bbox']['max_x'])
merged_item['bbox']['max_y'] = max(merged_item['bbox']['max_y'], neighbor_item['bbox']['max_y'])
visited.add(j)
merged.append(merged_item)
visited.add(i)
return merged
def _link_tags_to_equipment(self):
"""태그-설비 논리적 연결 (Association)"""
tags = [n for n, d in self.G.nodes(data=True) if d['type'] == 'TEXT']
equipments = [n for n, d in self.G.nodes(data=True) if d['type'] not in ['TEXT', 'LINE', 'LWPOLYLINE']]
for tag in tags:
best_match = self._find_nearest_equipment(tag, equipments)
if best_match:
self.G.add_edge(tag, best_match, relation='associated_with')
def _find_nearest_equipment(self, tag_id, equipment_ids):
tag_bbox = self.G.nodes[tag_id]['bbox']
min_dist = float('inf')
nearest = None
for eq_id in equipment_ids:
eq_bbox = self.G.nodes[eq_id]['bbox']
dist = tag_bbox.distance(eq_bbox)
if dist < min_dist:
min_dist = dist
nearest = eq_id
return nearest if min_dist < self.config['tag_threshold'] else None
def _link_pipes(self):
"""배관 기반 물리적 연결 (Pipe)"""
lines = [n for n, d in self.G.nodes(data=True) if d['type'] in ['LINE', 'LWPOLYLINE']]
equipments = [n for n, d in self.G.nodes(data=True) if d['type'] not in ['TEXT', 'LINE', 'LWPOLYLINE']]
for line_id in lines:
original_item = next((item for item in self.merged_data if item['entity_id'] == line_id), None)
if not original_item or not original_item.get('coordinates'):
continue
coords = original_item['coordinates']
line_geom = LineString(coords)
endpoints = [line_geom.coords[0], line_geom.coords[-1]]
connected_nodes = []
for pt in endpoints:
p = Point(pt)
for eq_id in equipments:
if self.G.nodes[eq_id]['bbox'].distance(p) < self.config['dist_threshold']:
connected_nodes.append(eq_id)
connected_nodes = list(set(connected_nodes))
if len(connected_nodes) >= 2:
self.G.add_edge(connected_nodes[0], connected_nodes[1], relation='pipe')
def validate_topology(self):
"""위상 무결성 검증"""
isolated = list(nx.isolates(self.G))
return {
"isolated_nodes": isolated,
"node_count": self.G.number_of_nodes(),
"edge_count": self.G.number_of_edges()
}
def save_graph(self, output_path: str):
"""그래프 구조를 JSON 형태로 저장"""
from networkx.readwrite import json_graph
data = json_graph.node_link_data(self.G)
with open(output_path, 'w', encoding='utf-8') as f:
json.dump(data, f, indent=2, ensure_ascii=False)
```
### 3.2 Phase 3: 병렬 LLM 매핑
#### 3.2.1 pid_extractor_line.py (LINE 배관 추출 - GPU 불필요)
```python
# mcp-server/pipeline/pid_extractor_line.py (신규 생성)
#!/usr/bin/env python3
"""
P&ID 도면에서 LINE (배관) 추출 (CPU 전용, GPU 불필요)
"""
import ezdxf
import json
import sys
def main():
if len(sys.argv) != 3:
print("Usage: python pid_extractor_line.py <dxf_file> <output_dir>")
sys.exit(1)
dxf_file = sys.argv[1]
output_dir = sys.argv[2]
# DXF 파일 읽기
doc = ezdxf.readfile(dxf_file)
msp = doc.modelspace()
# LINE 추출
lines = []
for entity in msp:
if entity.dxftype() == 'LINE':
start = entity.dxf.start
end = entity.dxf.end
line_data = {
'entity_id': entity.dxf.handle,
'entity_type': 'LINE',
'start': (start.x, start.y),
'end': (end.x, end.y),
'length': ((end.x - start.x)**2 + (end.y - start.y)**2)**0.5
}
lines.append(line_data)
# 결과 저장
output_file = f'{output_dir}/line_data.json'
with open(output_file, 'w', encoding='utf-8') as f:
json.dump(lines, f, indent=2, ensure_ascii=False)
print(f'LINE 추출 완료: {len(lines)}개')
if __name__ == '__main__':
main()
```
#### 3.2.2 pid_extractor_text.py (TEXT 태그 추출 - GPU 0)
```python
# mcp-server/pipeline/pid_extractor_text.py (신규 생성)
#!/usr/bin/env python3
"""
P&ID 도면에서 TEXT 태그 추출 (GPU 0 전용)
"""
import ezdxf
import json
import sys
from ezdxf.tools.text import plain_mtext
from openai import OpenAI
def main():
if len(sys.argv) != 3:
print("Usage: python pid_extractor_text.py <dxf_file> <output_dir>")
sys.exit(1)
dxf_file = sys.argv[1]
output_dir = sys.argv[2]
# DXF 파일 읽기
doc = ezdxf.readfile(dxf_file)
msp = doc.modelspace()
# 텍스트 추출
texts = []
for entity in msp:
if entity.dxftype() == 'TEXT':
texts.append(entity.dxf.text)
elif entity.dxftype() == 'MTEXT':
try:
plain = plain_mtext(entity.dxf.text)
if plain.strip():
texts.append(plain)
except Exception:
pass
text = '\n'.join(texts)
# OpenAI 클라이언트 생성
llm = OpenAI(
base_url='http://localhost:8000/v1',
api_key='dummy',
timeout=1800
)
# 프롬프트
system = (
'You are a P&ID expert. Extract all tag names from TEXT entities.\n'
'Return ONLY a JSON array.\n'
'\n'
'Format: [{"tagNo":"FICQ-10101","confidence":0.95},...]\n'
)
user = f'Extract ALL tag names from the text below:\n\n{text[:100000]}'
# LLM 호출
resp = llm.chat.completions.create(
model='Qwen/Qwen3-Coder-Next-FP8',
messages=[
{'role': 'system', 'content': system},
{'role': 'user', 'content': user},
],
max_tokens=65536,
temperature=0.1,
extra_body={'chat_template_kwargs': {'enable_thinking': False}},
)
# 결과 저장
raw = (resp.choices[0].message.content or '').strip()
try:
all_tags = json.loads(raw)
except json.JSONDecodeError:
all_tags = []
output_file = f'{output_dir}/text_tags.json'
with open(output_file, 'w', encoding='utf-8') as f:
json.dump(all_tags, f, indent=2, ensure_ascii=False)
print(f'TEXT 태그 추출 완료: {len(all_tags)}개')
if __name__ == '__main__':
main()
```
#### 3.2.3 pid_extractor_valve.py (Valve 태그 추출 - GPU 1)
```python
# mcp-server/pipeline/pid_extractor_valve.py (신규 생성)
#!/usr/bin/env python3
"""
P&ID 도면에서 Valve 태그 추출 (GPU 1 전용)
"""
import ezdxf
import json
import sys
from ezdxf.tools.text import plain_mtext
from openai import OpenAI
def main():
if len(sys.argv) != 3:
print("Usage: python pid_extractor_valve.py <dxf_file> <output_dir>")
sys.exit(1)
dxf_file = sys.argv[1]
output_dir = sys.argv[2]
# DXF 파일 읽기
doc = ezdxf.readfile(dxf_file)
msp = doc.modelspace()
# 텍스트 추출
texts = []
for entity in msp:
if entity.dxftype() == 'TEXT':
texts.append(entity.dxf.text)
elif entity.dxftype() == 'MTEXT':
try:
plain = plain_mtext(entity.dxf.text)
if plain.strip():
texts.append(plain)
except Exception:
pass
text = '\n'.join(texts)
# OpenAI 클라이언트 생성
llm = OpenAI(
base_url='http://localhost:8000/v1',
api_key='dummy',
timeout=1800
)
# 프롬프트
system = (
'You are a P&ID expert. Extract valve tags only.\n'
'Return ONLY a JSON array.\n'
'\n'
'Instrument types to extract: FCV, TCV, LCV, PCV, XV, FV, LV, PV, TV\n'
'Format: [{"tagNo":"FCV-10101","confidence":0.95},...]\n'
)
user = f'Extract ALL tags of FCV, TCV, LCV, PCV, XV, FV, LV, PV, TV from the text below:\n\n{text[:100000]}'
# LLM 호출
resp = llm.chat.completions.create(
model='Qwen/Qwen3-Coder-Next-FP8',
messages=[
{'role': 'system', 'content': system},
{'role': 'user', 'content': user},
],
max_tokens=65536,
temperature=0.1,
extra_body={'chat_template_kwargs': {'enable_thinking': False}},
)
# 결과 저장
raw = (resp.choices[0].message.content or '').strip()
try:
all_tags = json.loads(raw)
except json.JSONDecodeError:
all_tags = []
output_file = f'{output_dir}/valve_tags.json'
with open(output_file, 'w', encoding='utf-8') as f:
json.dump(all_tags, f, indent=2, ensure_ascii=False)
print(f'Valve 태그 추출 완료: {len(all_tags)}개')
if __name__ == '__main__':
main()
```
#### 3.2.4 pid_extractor_equipment.py (Equipment 태그 추출 - GPU 2)
```python
# mcp-server/pipeline/pid_extractor_equipment.py (신규 생성)
#!/usr/bin/env python3
"""
P&ID 도면에서 Equipment 태그 추출 (GPU 2 전용)
"""
import ezdxf
import json
import sys
from ezdxf.tools.text import plain_mtext
from openai import OpenAI
def main():
if len(sys.argv) != 3:
print("Usage: python pid_extractor_equipment.py <dxf_file> <output_dir>")
sys.exit(1)
dxf_file = sys.argv[1]
output_dir = sys.argv[2]
# DXF 파일 읽기
doc = ezdxf.readfile(dxf_file)
msp = doc.modelspace()
# 텍스트 추출
texts = []
for entity in msp:
if entity.dxftype() == 'TEXT':
texts.append(entity.dxf.text)
elif entity.dxftype() == 'MTEXT':
try:
plain = plain_mtext(entity.dxf.text)
if plain.strip():
texts.append(plain)
except Exception:
pass
text = '\n'.join(texts)
# OpenAI 클라이언트 생성
llm = OpenAI(
base_url='http://localhost:8000/v1',
api_key='dummy',
timeout=1800
)
# 프롬프트
system = (
'You are a P&ID expert. Extract equipment tags only.\n'
'Return ONLY a JSON array.\n'
'\n'
'Equipment types to extract: Pump, Tank, Heat Exchanger, Vessel, Column\n'
'Format: [{"tagNo":"P-101","confidence":0.95},...]\n'
)
user = f'Extract ALL tags of Pump, Tank, Heat Exchanger, Vessel, Column from the text below:\n\n{text[:100000]}'
# LLM 호출
resp = llm.chat.completions.create(
model='Qwen/Qwen3-Coder-Next-FP8',
messages=[
{'role': 'system', 'content': system},
{'role': 'user', 'content': user},
],
max_tokens=65536,
temperature=0.1,
extra_body={'chat_template_kwargs': {'enable_thinking': False}},
)
# 결과 저장
raw = (resp.choices[0].message.content or '').strip()
try:
all_tags = json.loads(raw)
except json.JSONDecodeError:
all_tags = []
output_file = f'{output_dir}/equipment_tags.json'
with open(output_file, 'w', encoding='utf-8') as f:
json.dump(all_tags, f, indent=2, ensure_ascii=False)
print(f'Equipment 태그 추출 완료: {len(all_tags)}개')
if __name__ == '__main__':
main()
```
#### 3.2.5 pid_extractor_system.py (System 태그 추출 - GPU 3)
```python
# mcp-server/pipeline/pid_extractor_system.py (신규 생성)
#!/usr/bin/env python3
"""
P&ID 도면에서 System 태그 추출 (GPU 3 전용)
"""
import ezdxf
import json
import sys
from ezdxf.tools.text import plain_mtext
from openai import OpenAI
def main():
if len(sys.argv) != 3:
print("Usage: python pid_extractor_system.py <dxf_file> <output_dir>")
sys.exit(1)
dxf_file = sys.argv[1]
output_dir = sys.argv[2]
# DXF 파일 읽기
doc = ezdxf.readfile(dxf_file)
msp = doc.modelspace()
# 텍스트 추출
texts = []
for entity in msp:
if entity.dxftype() == 'TEXT':
texts.append(entity.dxf.text)
elif entity.dxftype() == 'MTEXT':
try:
plain = plain_mtext(entity.dxf.text)
if plain.strip():
texts.append(plain)
except Exception:
pass
text = '\n'.join(texts)
# OpenAI 클라이언트 생성
llm = OpenAI(
base_url='http://localhost:8000/v1',
api_key='dummy',
timeout=1800
)
# 프롬프트
system = (
'You are a P&ID expert. Extract system tags only.\n'
'Return ONLY a JSON array.\n'
'\n'
'System types to extract: FICQ, TICA, PICA, LICA, FIC, TIC, PIC, LIC\n'
'Format: [{"tagNo":"FICQ-10101","confidence":0.95},...]\n'
)
user = f'Extract ALL tags of FICQ, TICA, PICA, LICA, FIC, TIC, PIC, LIC from the text below:\n\n{text[:100000]}'
# LLM 호출
resp = llm.chat.completions.create(
model='Qwen/Qwen3-Coder-Next-FP8',
messages=[
{'role': 'system', 'content': system},
{'role': 'user', 'content': user},
],
max_tokens=65536,
temperature=0.1,
extra_body={'chat_template_kwargs': {'enable_thinking': False}},
)
# 결과 저장
raw = (resp.choices[0].message.content or '').strip()
try:
all_tags = json.loads(raw)
except json.JSONDecodeError:
all_tags = []
output_file = f'{output_dir}/system_tags.json'
with open(output_file, 'w', encoding='utf-8') as f:
json.dump(all_tags, f, indent=2, ensure_ascii=False)
print(f'System 태그 추출 완료: {len(all_tags)}개')
if __name__ == '__main__':
main()
```
#### 3.2.6 merge_results.py (결과 병합)
```python
# mcp-server/pipeline/merge_results.py (신규 생성)
#!/usr/bin/env python3
"""
병렬 추출 결과 병합 스크립트
"""
import json
import sys
import glob
def main():
if len(sys.argv) != 3:
print("Usage: python merge_results.py <input_dir> <output_file>")
sys.exit(1)
input_dir = sys.argv[1]
output_file = sys.argv[2]
# 모든 JSON 파일 읽기
all_tags = []
seen_tags = set()
for filepath in glob.glob(f'{input_dir}/*_tags.json'):
with open(filepath, 'r', encoding='utf-8') as f:
tags = json.load(f)
for tag in tags:
tag_no = tag.get('tagNo')
if tag_no and tag_no not in seen_tags:
seen_tags.add(tag_no)
all_tags.append(tag)
# 결과 저장
with open(output_file, 'w', encoding='utf-8') as f:
json.dump(all_tags, f, indent=2, ensure_ascii=False)
print(f'총 추출 태그 수: {len(all_tags)}개')
if __name__ == '__main__':
main()
```
### 3.3 run_parallel_extract.sh (병렬 실행 스크립트)
```bash
# mcp-server/run_parallel_extract.sh (신규 생성)
#!/bin/bash
# P&ID 태그 추출 병렬 실행 스크립트
DXF_FILE="/path/to/pid.dxf"
OUTPUT_DIR="/path/to/output"
# Phase 1: 기하학적 추출 (ezdxf)
echo "Phase 1: 기하학적 추출 시작..."
python -m pipeline.extractor "$DXF_FILE" "$OUTPUT_DIR/geometric_data.json"
echo "Phase 1 완료: geometric_data.json 저장"
# Phase 2: 위상 빌더 (공간 인덱스)
echo "Phase 2: 위상 빌더 시작..."
python -m pipeline.topology "$OUTPUT_DIR/geometric_data.json" "$OUTPUT_DIR/topology.json"
echo "Phase 2 완료: topology.json 저장"
# Phase 3: 병렬 LLM 매핑 (4개 프로그램 동시에 실행)
echo "Phase 3: 병렬 LLM 매핑 시작..."
# GPU 0: TEXT 태그 추출
python -m pipeline.pid_extractor_text "$DXF_FILE" "$OUTPUT_DIR" &
# GPU 1: VALVE 태그 추출
python -m pipeline.pid_extractor_valve "$DXF_FILE" "$OUTPUT_DIR" &
# GPU 2: EQUIPMENT 태그 추출
python -m pipeline.pid_extractor_equipment "$DXF_FILE" "$OUTPUT_DIR" &
# GPU 3: SYSTEM 태그 추출
python -m pipeline.pid_extractor_system "$DXF_FILE" "$OUTPUT_DIR" &
# 모든 프로세스가 완료될 때까지 대기
wait
# 결과 병합
echo "결과 병합 시작..."
python -m pipeline.merge_results "$OUTPUT_DIR" "$OUTPUT_DIR/merged_tags.json"
echo "Phase 3 완료: merged_tags.json 저장"
echo "전체 파이프라인 완료!"
```
---
## 4. 성능 예측
### 4.1 Phase 1: 기하학적 추출
- **현재**: 1.4초
- **개선 후**: 1.4초 (변화 없음)
### 4.2 Phase 2: 위상 빌더
- **현재**: timeout (O(n²))
- **개선 후**: 2-3초 (R-tree O(n log n))
### 4.3 Phase 3: 병렬 LLM 매핑
- **현재**: 예측 불가 (순차적 API 호출)
- **개선 후**: 5-10초 (4개 프로그램 병렬 실행)
**예상 속도 향상**:
- Phase 2: 100배 이상 (timeout → 2-3초)
- Phase 3: 3-5배 (순차적 → 병렬)
---
## 5. 구현 우선순위
| 순위 | 작업 | 예상 시간 | 영향도 |
|------|------|-----------|--------|
| 1 | R-tree 공간 인덱스 도입 | 1일 | HIGH |
| 2 | pid_extractor_line.py 구현 (LINE 추출) | 0.5일 | HIGH |
| 3 | pid_extractor_text.py 구현 (TEXT 추출) | 0.5일 | HIGH |
| 4 | pid_extractor_valve.py 구현 | 0.5일 | HIGH |
| 5 | pid_extractor_equipment.py 구현 | 0.5일 | HIGH |
| 6 | pid_extractor_system.py 구현 | 0.5일 | HIGH |
| 7 | merge_results.py 구현 | 0.5일 | LOW |
| 8 | run_parallel_extract.sh 구현 | 0.5일 | LOW |
| 9 | 테스트 및 벤치마크 | 0.5일 | LOW |
**총 예상 시간**: 4.5일
---
## 6. GPU 자원 활용 전략
### 6.1 vLLM의 GPU 할당 방식
**단일 프로세스 (현재 구조)**:
```
Python 프로세스 A
├─ LLM Request 1 → GPU 0 (100% 사용)
├─ LLM Request 2 → GPU 0 (대기)
└─ LLM Request 3 → GPU 0 (대기)
```
→ GPU 1, 2, 3은 놀고 있음
**다중 프로세스 (개선안)**:
```
Python 프로세스 A → GPU 0 (100% 사용)
Python 프로세스 B → GPU 1 (100% 사용)
Python 프로세스 C → GPU 2 (100% 사용)
Python 프로세스 D → GPU 3 (100% 사용)
```
→ 모든 GPU 카드를 100% 활용
### 6.2 병렬 실행 명령어
```bash
# 4개 프로그램을 동시에 실행
python -m pipeline.pid_extractor_text /path/to/pid.dxf /path/to/output &
python -m pipeline.pid_extractor_valve /path/to/pid.dxf /path/to/output &
python -m pipeline.pid_extractor_equipment /path/to/pid.dxf /path/to/output &
python -m pipeline.pid_extractor_system /path/to/pid.dxf /path/to/output &
# 모든 프로세스가 완료될 때까지 대기
wait
# 결과 병합
python -m pipeline.merge_results /path/to/output /path/to/output/merged_tags.json
```
---
## 7. 현재 프로젝트와의 차이점
| 항목 | 기존 구조 | 개선안 |
|------|-----------|--------|
| **Phase 2** | O(n²) 병합 → timeout | R-tree O(n log n) → 2-3초 |
| **Phase 3** | 비동기 순차적 LLM 호출 | 4개 프로그램 병렬 실행 |
| **LINE 처리** | LLM 매핑 대상 | CPU 전용 기하학적 추출 |
| **GPU 활용** | 단일 GPU만 사용 | 4개 GPU 모두 사용 |
| **파일 구조** | `pid_intelligent_mapper.py` | `pid_extractor_*.py` (4개) |
---
## 8. 구현 체크리스트
- [ ] R-tree 패키지 추가 (`pyproject.toml`)
- [ ] `topology.py`에 `_build_spatial_index()` 및 `_merge_nodes_spatial()` 구현
- [ ] `pid_extractor_line.py` 생성 (LINE 추출)
- [ ] `pid_extractor_text.py` 생성 (TEXT 추출)
- [ ] `pid_extractor_valve.py` 생성 (Valve 추출)
- [ ] `pid_extractor_equipment.py` 생성 (Equipment 추출)
- [ ] `pid_extractor_system.py` 생성 (System 추출)
- [ ] `merge_results.py` 생성 (결과 병합)
- [ ] `run_parallel_extract.sh` 생성 (병렬 실행 스크립트)
- [ ] 전체 파이프라인 테스트 및 벤치마크
---
## 9. 참고 자료
- [`P&ID_병렬LLM_아키텍처_개선안_v2.md`](P&ID_병렬LLM_아키텍처_개선안_v2.md:1) - 원본 개선안
- [`P&ID_병목현상_분석_보고서.md`](P&ID_병목현상_분석_보고서.md:1) - 병목 분석 보고서
- [`P&ID_병렬LLM_아키텍처_개선안.md`](P&ID_병렬LLM_아키텍처_개선안.md:1) - 이전 개선안
- [`futurePlan/End-to-End P&ID Graph Pipeline/`](futurePlan/End-to-End%20P&ID%20Graph%20Pipeline/) - 기존 파이프라인 코드
Reference in New Issue View Git Blame Copy Permalink