htlee
0a4d023c76
5가지 출력 이상 동시 해결:
1. stats_aggregator (이상 1, 5)
- aggregate_hourly에 by_category, by_zone JSON 집계 추가
- hour_start를 KST 기준으로 변경 (대시보드 표기와 boundary 일치)
2. event_generator 룰 정리 (이상 2, 3, 4)
- critical_risk 임계값 90→70 (risk.py CRITICAL 분류와 일치)
- territorial_sea_violation, contiguous_zone_high_risk, special_zone_entry 신설
(실측 zone_code: TERRITORIAL_SEA/CONTIGUOUS_ZONE/ZONE_*)
- 잘못된 NLL/SPECIAL_FISHING_* 룰 제거
- HIGH_RISK_VESSEL 신규 카테고리 (50~69 MEDIUM, 70+ CRITICAL)
- break 제거: 한 분석결과가 여러 카테고리에 동시 매칭 가능
3. dedup window prime 분산 (이상 5)
- 30/60/120/360분 → 33/67/127/367분
- 5분 사이클 boundary와 LCM 회피하여 정시 일제 만료 패턴 완화
4. lightweight path 신호 보강 (이상 2, 3, 4 근본 해결)
- vessel_store._tracks의 24h 누적 궤적으로 dark/spoof/speed_jump 산출
- 6,500 vessels(전체 93%)의 is_dark, spoofing_score가 비로소 채워짐
- compute_lightweight_risk_score에 dark gap, spoofing 가점 추가
(max 60→100 가능, CRITICAL 도달 가능)
시간 처리 원칙 적용:
- DB 컬럼은 모두 timestamptz 확인 완료
- aggregate_hourly KST aware datetime 사용
- pandas Timestamp는 source-internal 비교만 (안전)
227 lines
8.2 KiB
Python
227 lines
8.2 KiB
Python
"""
|
|
이벤트 자동 생성기 — 분석 결과 → prediction_events INSERT.
|
|
|
|
매 분석 사이클마다 vessel_analysis_results를 스캔하여
|
|
룰 기반으로 Event 객체를 생성합니다.
|
|
dedup: 동일 mmsi + category + 윈도우 내 중복 방지.
|
|
"""
|
|
import hashlib
|
|
import logging
|
|
from datetime import datetime, timedelta, timezone
|
|
from typing import Optional
|
|
|
|
from psycopg2.extras import execute_values
|
|
|
|
from config import qualified_table, settings
|
|
from db.kcgdb import get_conn
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
EVENTS_TABLE = qualified_table('prediction_events')
|
|
|
|
# 카테고리별 dedup 윈도우 (분).
|
|
# 사이클이 5분 간격이므로 5의 배수를 피해서 boundary 일제 만료 패턴을 회피한다.
|
|
DEDUP_WINDOWS = {
|
|
'EEZ_INTRUSION': 33,
|
|
'DARK_VESSEL': 127,
|
|
'FLEET_CLUSTER': 367,
|
|
'ILLEGAL_TRANSSHIP': 67,
|
|
'MMSI_TAMPERING': 33,
|
|
'AIS_LOSS': 127,
|
|
'SPEED_ANOMALY': 67,
|
|
'ZONE_DEPARTURE': 127,
|
|
'GEAR_ILLEGAL': 367,
|
|
'AIS_RESUME': 67,
|
|
'HIGH_RISK_VESSEL': 67,
|
|
}
|
|
|
|
# 이벤트 생성 룰
|
|
# 한 분석결과가 여러 룰에 매칭되면 모두 생성한다 (카테고리별 dedup_key가 분리되어 안전).
|
|
# zone_code 실측값: EEZ_OR_BEYOND/ZONE_II/III/IV/CONTIGUOUS_ZONE/TERRITORIAL_SEA
|
|
# (algorithms.location.classify_zone 결과)
|
|
RULES = [
|
|
{
|
|
# 영해 침범 — 가장 심각
|
|
'name': 'territorial_sea_violation',
|
|
'condition': lambda r: r.get('zone_code') == 'TERRITORIAL_SEA',
|
|
'level': 'CRITICAL',
|
|
'category': 'EEZ_INTRUSION',
|
|
'title_fn': lambda r: f"영해 침범 탐지 (위험도 {r.get('risk_score', 0)})",
|
|
},
|
|
{
|
|
# 접속수역 + 고위험
|
|
'name': 'contiguous_zone_high_risk',
|
|
'condition': lambda r: r.get('zone_code') == 'CONTIGUOUS_ZONE'
|
|
and (r.get('risk_score', 0) or 0) >= 50,
|
|
'level': 'HIGH',
|
|
'category': 'EEZ_INTRUSION',
|
|
'title_fn': lambda r: f"접속수역 침입 (위험도 {r.get('risk_score', 0)})",
|
|
},
|
|
{
|
|
# 종합 위험도 CRITICAL — risk.py 분류와 동일 임계값
|
|
'name': 'critical_risk',
|
|
'condition': lambda r: (r.get('risk_score', 0) or 0) >= 70,
|
|
'level': 'CRITICAL',
|
|
'category': 'HIGH_RISK_VESSEL',
|
|
'title_fn': lambda r: f"고위험 선박 탐지 (위험도 {r.get('risk_score', 0)})",
|
|
},
|
|
{
|
|
'name': 'dark_vessel_long',
|
|
'condition': lambda r: r.get('is_dark') and (r.get('gap_duration_min', 0) or 0) > 60,
|
|
'level': 'HIGH',
|
|
'category': 'DARK_VESSEL',
|
|
'title_fn': lambda r: f"다크베셀 장기 소실 ({r.get('gap_duration_min', 0)}분)",
|
|
},
|
|
{
|
|
'name': 'spoofing',
|
|
'condition': lambda r: (r.get('spoofing_score', 0) or 0) > 0.7,
|
|
'level': 'HIGH',
|
|
'category': 'MMSI_TAMPERING',
|
|
'title_fn': lambda r: f"GPS/MMSI 조작 의심 (점수 {r.get('spoofing_score', 0):.2f})",
|
|
},
|
|
{
|
|
'name': 'transship',
|
|
'condition': lambda r: r.get('transship_suspect'),
|
|
'level': 'HIGH',
|
|
'category': 'ILLEGAL_TRANSSHIP',
|
|
'title_fn': lambda r: f"환적 의심 (상대: {r.get('transship_pair_mmsi', '미상')})",
|
|
},
|
|
{
|
|
'name': 'fleet_cluster',
|
|
'condition': lambda r: r.get('fleet_is_leader') and (r.get('fleet_cluster_id') is not None),
|
|
'level': 'MEDIUM',
|
|
'category': 'FLEET_CLUSTER',
|
|
'title_fn': lambda r: f"선단 밀집 감지 (클러스터 {r.get('fleet_cluster_id')})",
|
|
},
|
|
{
|
|
# 특정수역(ZONE_*) 진입 — 운영자 모니터링용
|
|
'name': 'special_zone_entry',
|
|
'condition': lambda r: (r.get('zone_code') or '').startswith('ZONE_')
|
|
and (r.get('risk_score', 0) or 0) >= 40,
|
|
'level': 'MEDIUM',
|
|
'category': 'ZONE_DEPARTURE',
|
|
'title_fn': lambda r: f"특정수역 진입 ({r.get('zone_code')}, 위험도 {r.get('risk_score', 0)})",
|
|
},
|
|
{
|
|
# 고위험 행동 패턴 (risk_level=HIGH 이상은 위 critical_risk가 잡고, 50~69점만 여기에)
|
|
'name': 'high_risk',
|
|
'condition': lambda r: 50 <= (r.get('risk_score', 0) or 0) < 70,
|
|
'level': 'MEDIUM',
|
|
'category': 'HIGH_RISK_VESSEL',
|
|
'title_fn': lambda r: f"위험 행동 패턴 (위험도 {r.get('risk_score', 0)})",
|
|
},
|
|
]
|
|
|
|
|
|
def _make_dedup_key(mmsi: str, category: str) -> str:
|
|
return f"{mmsi}:{category}"
|
|
|
|
|
|
def _make_event_uid(now: datetime, seq: int) -> str:
|
|
date_str = now.strftime('%Y%m%d')
|
|
return f"EVT-{date_str}-{seq:04d}"
|
|
|
|
|
|
def _get_next_seq(conn, date_str: str) -> int:
|
|
cur = conn.cursor()
|
|
cur.execute(
|
|
f"SELECT COUNT(*) FROM {EVENTS_TABLE} WHERE event_uid LIKE %s",
|
|
(f'EVT-{date_str}-%',)
|
|
)
|
|
return cur.fetchone()[0] + 1
|
|
|
|
|
|
def _check_dedup(conn, dedup_key: str, category: str, now: datetime) -> bool:
|
|
"""중복 이벤트 존재 여부 확인."""
|
|
window_min = DEDUP_WINDOWS.get(category, 60)
|
|
cutoff = now - timedelta(minutes=window_min)
|
|
cur = conn.cursor()
|
|
cur.execute(
|
|
f"SELECT 1 FROM {EVENTS_TABLE} WHERE dedup_key = %s AND occurred_at > %s LIMIT 1",
|
|
(dedup_key, cutoff)
|
|
)
|
|
return cur.fetchone() is not None
|
|
|
|
|
|
def run_event_generator(analysis_results: list[dict]) -> dict:
|
|
"""
|
|
분석 결과 리스트를 스캔하여 이벤트 생성.
|
|
|
|
Args:
|
|
analysis_results: vessel_analysis_results 행 딕셔너리 리스트
|
|
(mmsi, risk_score, zone_code, is_dark, gap_duration_min, spoofing_score, ...)
|
|
|
|
Returns:
|
|
{ 'generated': int, 'skipped_dedup': int }
|
|
"""
|
|
now = datetime.now(timezone.utc)
|
|
generated = 0
|
|
skipped_dedup = 0
|
|
events_to_insert = []
|
|
|
|
with get_conn() as conn:
|
|
date_str = now.strftime('%Y%m%d')
|
|
seq = _get_next_seq(conn, date_str)
|
|
|
|
for result in analysis_results:
|
|
mmsi = result.get('mmsi', '')
|
|
if not mmsi:
|
|
continue
|
|
|
|
for rule in RULES:
|
|
try:
|
|
if not rule['condition'](result):
|
|
continue
|
|
except Exception:
|
|
continue
|
|
|
|
category = rule['category']
|
|
dedup_key = _make_dedup_key(mmsi, category)
|
|
|
|
if _check_dedup(conn, dedup_key, category, now):
|
|
skipped_dedup += 1
|
|
continue
|
|
|
|
event_uid = _make_event_uid(now, seq)
|
|
seq += 1
|
|
|
|
events_to_insert.append((
|
|
event_uid,
|
|
now, # occurred_at
|
|
rule['level'],
|
|
category,
|
|
rule['title_fn'](result), # title
|
|
None, # detail
|
|
mmsi,
|
|
result.get('vessel_name'),
|
|
result.get('zone_code'), # area_name (zone으로 대체)
|
|
result.get('zone_code'),
|
|
result.get('lat'),
|
|
result.get('lon'),
|
|
result.get('speed_kn'),
|
|
'VESSEL_ANALYSIS', # source_type
|
|
result.get('id'), # source_ref_id
|
|
result.get('confidence') or result.get('risk_score', 0) / 100.0,
|
|
'NEW', # status
|
|
dedup_key,
|
|
))
|
|
generated += 1
|
|
# break 제거: 한 분석결과가 여러 룰에 매칭되면 모두 생성
|
|
# (카테고리별 dedup_key가 분리되어 안전)
|
|
|
|
if events_to_insert:
|
|
execute_values(
|
|
conn.cursor(),
|
|
f"""INSERT INTO {EVENTS_TABLE}
|
|
(event_uid, occurred_at, level, category, title, detail,
|
|
vessel_mmsi, vessel_name, area_name, zone_code, lat, lon, speed_kn,
|
|
source_type, source_ref_id, ai_confidence, status, dedup_key)
|
|
VALUES %s
|
|
ON CONFLICT (event_uid) DO NOTHING""",
|
|
events_to_insert,
|
|
)
|
|
conn.commit()
|
|
|
|
logger.info(f'event_generator: generated={generated}, skipped_dedup={skipped_dedup}')
|
|
return {'generated': generated, 'skipped_dedup': skipped_dedup}
|