Update app.py

app.py

@@ -1,8 +1,8 @@
 """
-AI 글 판별기 v5.0 — 5축 AI 탐지 + 품질 측정 + LLM 교차검증 + 표절 검사
+AI 글 판별기 v5.1 — 5축+Perplexity+Humanizer+모델추정 + 품질 + LLM교차검증 + 표절
 ═══════════════════════════════════════════════════════════════════════════
-5축 AI 탐지 | 6항목 품질 | LLM 교차검증 (GPT-OSS-120B · Qwen3-32B · Kimi-K2)
-★ LLM 교차검증: 3모델 (GPT-OSS/Qwen3/Kimi-K2) 투표 + 강건한 파싱
+★ v5.1 3대 킬러: Perplexity 확률분석 · Humanizer/Bypasser 탐지 · AI 모델 추정
+★ 5축 AI 탐지 | 6항목 품질 | LLM 교차검증 (GPT-OSS-120B · Qwen3-32B · Kimi-K2)
 ★ 표절: Brave Search 병렬(최대20) + KCI/RISS/ARXIV + Gemini + CopyKiller 보고서
 ★ 문서: PDF·DOCX·HWP·HWPX·TXT 업로드 → 섹션별 히트맵 + PDF 보고서
 """
@@ -688,6 +688,283 @@ def analyze_model_fingerprint(text, sentences):
     base = 85 if mx>=50 else 65 if mx>=35 else 45 if mx>=20 else 25 if mx>=10 else 10
     return {"score":min(95, base + multi_bonus),"model_scores":{k:v for k,v in ms.items() if k not in ("비격식AI","영어AI") or v > 0}}
 
+# ═══════════════════════════════════════════════
+# ★★★ 킬러 기능 ① — Perplexity 기반 AI 확률 (v5.1)
+# ═══════════════════════════════════════════════
+# AI 텍스트는 예측 가능도가 높음 (낮은 Perplexity) → 문자/형태소 n-gram 기반
+def analyze_perplexity(text, sentences, morphemes):
+    """한국어 특화 Perplexity + Burstiness — 문자 엔트로피 보정"""
+    if len(sentences) < 2: return {"score": 40, "entropy": 0, "variance": 0, "order": 0, "zipf": 0}
+
+    # === 1. 문자 바이그램 엔트로피 (형태소보다 안정적) ===
+    chars = [c for c in text if c.strip()]
+    char_score = 45
+    if len(chars) >= 30:
+        cbigrams = [(chars[i], chars[i+1]) for i in range(len(chars)-1)]
+        cb_freq = Counter(cbigrams)
+        total_cb = len(cbigrams)
+        char_entropy = -sum((cnt/total_cb)*math.log2(cnt/total_cb) for cnt in cb_freq.values())
+        # AI 한국어: ~7~9비트, 인간: ~9~12비트
+        if char_entropy < 7.5: char_score = 78
+        elif char_entropy < 8.5: char_score = 62
+        elif char_entropy < 9.5: char_score = 42
+        elif char_entropy < 10.5: char_score = 25
+        else: char_score = 12
+
+    # === 2. 문장 길이 Burstiness (CV) ===
+    sl = [len(s) for s in sentences]
+    burst_score = 45
+    if len(sl) >= 3:
+        avg = sum(sl)/len(sl)
+        std = math.sqrt(sum((l-avg)**2 for l in sl)/len(sl))
+        cv = std/(avg+1e-10)
+        if cv < 0.15: burst_score = 82
+        elif cv < 0.25: burst_score = 62
+        elif cv < 0.40: burst_score = 38
+        elif cv < 0.60: burst_score = 20
+        else: burst_score = 8
+
+    # === 3. 문장간 어휘밀도(TTR) 편차 ===
+    sent_ttr = []
+    for s in sentences:
+        sw = split_words(s)
+        if len(sw) >= 3:
+            sent_ttr.append(len(set(sw))/len(sw))
+    ttr_score = 42
+    if len(sent_ttr) >= 3:
+        avg_ttr = sum(sent_ttr)/len(sent_ttr)
+        std_ttr = math.sqrt(sum((t-avg_ttr)**2 for t in sent_ttr)/len(sent_ttr))
+        if std_ttr < 0.04: ttr_score = 75
+        elif std_ttr < 0.08: ttr_score = 55
+        elif std_ttr < 0.15: ttr_score = 35
+        else: ttr_score = 15
+
+    # === 4. 종결어미 엔트로피 ===
+    endings = [s.rstrip('.!?\u2026')[-3:] for s in sentences if len(s) >= 5]
+    end_score = 40
+    if len(endings) >= 3:
+        ef = Counter(endings)
+        end_ent = -sum((c/len(endings))*math.log2(c/len(endings)) for c in ef.values())
+        max_ent = math.log2(len(ef)) if len(ef) > 1 else 1
+        norm_ent = end_ent / (max_ent + 1e-10)
+        if norm_ent < 0.5: end_score = 72
+        elif norm_ent < 0.7: end_score = 50
+        elif norm_ent < 0.85: end_score = 32
+        else: end_score = 15
+
+    final = int(char_score * 0.30 + burst_score * 0.30 + ttr_score * 0.20 + end_score * 0.20)
+    return {"score": final, "entropy": char_score, "variance": burst_score, "order": ttr_score, "zipf": end_score}
+
+
+# ═══════════════════════════════════════════════
+# ★★★ 킬러 기능 ② — Humanizer/Bypasser 탐지 (v5.1)
+# ═══════════════════════════════════════════════
+# 패러프레이즈 도구(QuillBot 등)로 수정된 AI 글의 잔존 흔적 탐지
+
+# Humanizer 특유 패턴
+HUMANIZER_OVERSUBST = re.compile(r'활용하다|이용하다|사용하다|적용하다|도입하다|채택하다|수행하다|진행하다|실시하다|실행하다')
+HUMANIZER_AWKWARD = re.compile(r'그것은|이것은|저것은|해당 사항|앞서 언급한|전술한|상기한|기술된')
+HUMANIZER_PASSIVE = re.compile(r'되어지[고는며]|하게 되었[다습]|수행되[었어]|진행되[었어]|실시되[었어]|활용되[었어]')
+
+def analyze_humanizer(text, sentences, words, morphemes):
+    """Humanizer/Bypasser 탐지 — AI 원문 패러프레이즈 흔적 분석"""
+    if len(sentences) < 2: return {"score": 20, "signals": []}
+    signals = []
+
+    # === 1. 동의어 과다 치환 패턴 ===
+    # Humanizer는 같은 의미를 다양한 동의어로 바꿈 → 비자연적 어휘 분산
+    content_words = [f for f, t in morphemes if t in ('NNG', 'NNP', 'VV', 'VA')]
+    if len(content_words) >= 10:
+        cw_freq = Counter(content_words)
+        # Hapax ratio 극단적으로 높으면 동의어 치환 의심
+        hapax = sum(1 for c in cw_freq.values() if c == 1)
+        hapax_ratio = hapax / len(cw_freq) if cw_freq else 0
+        # 자연어: 0.4~0.7, Humanizer: 0.8+ (모든 단어를 다 바꿔서)
+        if hapax_ratio > 0.95 and len(content_words) >= 30:
+            signals.append(("동의어과다치환", 20, "핵심 어휘가 과도하게 분산"))
+        elif hapax_ratio > 0.90 and len(content_words) >= 25:
+            signals.append(("동의어치환의심", 12, "어휘 반복 회피 패턴"))
+
+    # === 2. 구조 보존 + 어휘만 변경 패턴 ===
+    # 원문 AI의 문장 구조(길이, 어순)는 유지되면서 단어만 바뀜
+    sl = [len(s) for s in sentences]
+    if len(sl) >= 4:
+        avg = sum(sl) / len(sl)
+        cv = math.sqrt(sum((l - avg)**2 for l in sl) / len(sl)) / (avg + 1e-10)
+        # 문장 길이 균일 + 어휘 다양 = Humanizer 패턴
+        unique_ratio = len(set(words)) / len(words) if words else 0
+        if cv < 0.20 and unique_ratio > 0.80 and len(sentences) >= 5:
+            signals.append(("구조보존어휘변경", 18, "문장 구조 균일 + 비정상적 어휘 다양성"))
+
+    # === 3. 잔존 AI 패턴 ===
+    # Humanizer가 놓치기 쉬운 AI 흔적
+    residual = 0
+    # 접속사 위치 규칙성 (Humanizer는 접속사를 잘 안 바꿈)
+    conn_positions = []
+    for i, s in enumerate(sentences):
+        stripped = s.strip()
+        for c in ['또한','특히','한편','더불어','아울러','나아가','이에','게다가','반면','결국']:
+            if stripped.startswith(c):
+                conn_positions.append(i)
+                break
+    if len(conn_positions) >= 2:
+        # 등간격 접속사 = AI 원문 구조 잔존
+        gaps = [conn_positions[i] - conn_positions[i-1] for i in range(1, len(conn_positions))]
+        if gaps and max(gaps) - min(gaps) <= 1:  # 거의 등간격
+            signals.append(("접속사등간격잔존", 15, "접속사 배치가 규칙적 (AI 원문 구조 잔존)"))
+            residual += 15
+
+    # === 4. 부자연스러운 대체 표현 ===
+    oversubst = len(HUMANIZER_OVERSUBST.findall(text))
+    awkward = len(HUMANIZER_AWKWARD.findall(text))
+    passive = len(HUMANIZER_PASSIVE.findall(text))
+    if oversubst >= 3:
+        signals.append(("유사동사난무", 12, f"활용/이용/사용/적용 등 {oversubst}개"))
+    if awkward >= 2:
+        signals.append(("어색한지시어", 10, f"해당/전술/상기 등 {awkward}개"))
+    if passive >= 3:
+        signals.append(("이중피동과다", 15, f"되어지/수행되 등 {passive}개"))
+
+    # === 5. 문장 유형 단조 + 어미 다양 = Humanizer 시그니처 ===
+    # AI 원문: 문장유형 단조 + 어미 단조
+    # 인간: 문장유형 다양 + 어미 다양
+    # Humanizer: 문장유형 단조(바꿀 수 없음) + 어미 다양(바꿈) → 부조화
+    endings = [s.rstrip('.!?')[-2:] for s in sentences if len(s) >= 4]
+    end_types = len(set(endings)) / len(endings) if endings else 0
+    has_question = any(s.strip().endswith('?') for s in sentences)
+    has_exclaim = any(s.strip().endswith('!') for s in sentences)
+    sent_type_variety = sum([has_question, has_exclaim])
+    if sent_type_variety == 0 and end_types > 0.85 and len(sentences) >= 6:
+        signals.append(("유형단조어미다양", 12, "서술문만 + 종결어미 과다 다양 = Humanizer 패턴"))
+
+    # === 6. 문장 시작 패턴 불일치 ===
+    # Humanizer는 문두를 다양하게 바꾸려 하나, 한국어에서는 부자연스러움 유발
+    starters = [s.strip()[:3] for s in sentences if len(s) >= 6]
+    starter_unique = len(set(starters)) / len(starters) if starters else 0
+    if starter_unique >= 0.98 and len(sentences) >= 7:
+        signals.append(("문두과다다양", 8, "모든 문장 시작이 다름 (자연스럽지 않은 다양성)"))
+
+    total = sum(s[1] for s in signals)
+    # 점수화
+    if total >= 45: score = 85
+    elif total >= 30: score = 68
+    elif total >= 20: score = 52
+    elif total >= 10: score = 35
+    else: score = 15
+
+    return {"score": score, "signals": signals, "total_evidence": total}
+
+# ═══════���═══════════════════════════════════════
+# ★★★ 킬러 기능 ③ — AI 모델 추정 (v5.1)
+# ═══════════════════════════════════════════════
+# 모델별 고유 특성으로 작성 모델 추정
+
+MODEL_PROFILES = {
+    "GPT": {
+        "style": ["격식체 ~습니다", "또한/특히 접속사", "~에 대해", "~것으로 예상됩니다"],
+        "markers": ["다양한", "중요한 역할", "긍정적인", "눈부신", "주목할 만한", "살펴보겠습니다"],
+        "structure": "균일한 문단, 서론-본론-결론 구조, 마크다운 선호",
+        "endings": ["습니다", "있습니다", "됩니다", "입니다"],
+        "connectors": ["또한", "특히", "한편", "이처럼"],
+    },
+    "Claude": {
+        "style": ["맥락 제시", "균형 잡힌", "사려 깊은 어조", "양보 후 주장"],
+        "markers": ["흥미로운 질문", "복잡한 주제", "맥락에서", "균형 잡힌", "살펴보겠습니다", "한 가지 주의할"],
+        "structure": "자연스러운 흐름, 양보-주장 구문 선호, 부드러운 전환",
+        "endings": ["네요", "입니다", "있습니다", "습니다"],
+        "connectors": ["한편", "물론", "다만", "이와 관련해"],
+    },
+    "Gemini": {
+        "style": ["정보 나열형", "~에 대해 알아보겠습니다", "검색 결과 기반"],
+        "markers": ["알아보겠습니다", "도움이 되셨으면", "추가 질문", "참고로"],
+        "structure": "리스트/번호 매기기 선호, 헤더 활용, 정보 밀도 높음",
+        "endings": ["습니다", "있습니다", "세요"],
+        "connectors": ["또한", "그리고", "참고로"],
+    },
+    "Perplexity": {
+        "style": ["출처 인용형", "~에 따르면", "수치 제시", "것으로 나타났다"],
+        "markers": ["에 따르면", "것으로 나타났", "것으로 조사됐", "것으로 집계됐", "발표했", "보도에 따르면"],
+        "structure": "팩트 중심, 수치 인용 다수, 출처 명시 스타일",
+        "endings": ["습니다", "나타났다", "밝혔다", "전했다"],
+        "connectors": ["한편", "또한", "이에"],
+    },
+}
+
+def estimate_model(text, sentences, morphemes, model_scores):
+    """AI 모델 추정 — 복합 증거 기반"""
+    evidence = {m: {"score": 0, "reasons": []} for m in MODEL_PROFILES}
+
+    sl = text.lower()
+
+    for model, profile in MODEL_PROFILES.items():
+        # 1. FP 점수 반영 (기존 지문 분석)
+        fp_score = model_scores.get(model, 0)
+        evidence[model]["score"] += fp_score * 0.4
+        if fp_score >= 20:
+            evidence[model]["reasons"].append(f"지문 매칭 {fp_score}점")
+
+        # 2. 마커 매칭
+        marker_cnt = sum(1 for m in profile["markers"] if m in text)
+        if marker_cnt >= 2:
+            evidence[model]["score"] += marker_cnt * 8
+            evidence[model]["reasons"].append(f"특유 표현 {marker_cnt}개")
+
+        # 3. 종결어미 패턴
+        end_match = 0
+        for s in sentences:
+            for e in profile["endings"]:
+                if s.rstrip('.!?').endswith(e):
+                    end_match += 1; break
+        if sentences:
+            end_ratio = end_match / len(sentences)
+            if end_ratio > 0.7:
+                evidence[model]["score"] += 12
+                evidence[model]["reasons"].append(f"종결어미 {end_ratio:.0%} 일치")
+
+        # 4. 접속사 패턴
+        conn_match = sum(1 for s in sentences if any(s.strip().startswith(c) for c in profile["connectors"]))
+        if conn_match >= 2:
+            evidence[model]["score"] += conn_match * 4
+            evidence[model]["reasons"].append(f"접속사 패턴 {conn_match}회")
+
+    # Perplexity 특화: 수치 + 출처 인용
+    number_citations = len(re.findall(r'\d+[%만억조]|에 따르면|것으로 나타났|발표했', text))
+    if number_citations >= 3:
+        evidence["Perplexity"]["score"] += number_citations * 5
+        evidence["Perplexity"]["reasons"].append(f"수치/인용 {number_citations}회")
+
+    # Claude 특화: 양보-주장 구문
+    concession_cnt = len(AI_CONCESSION.findall(text))
+    if concession_cnt >= 1:
+        evidence["Claude"]["score"] += concession_cnt * 10
+        evidence["Claude"]["reasons"].append(f"양보-주장 구문 {concession_cnt}회")
+
+    # 정렬 및 판정
+    ranked = sorted(evidence.items(), key=lambda x: x[1]["score"], reverse=True)
+    top = ranked[0]
+    second = ranked[1] if len(ranked) > 1 else None
+
+    if top[1]["score"] < 10:
+        return {"model": "특정 불가", "confidence": "낮음", "detail": evidence, "ranked": ranked}
+
+    # 신뢰도 계산
+    gap = top[1]["score"] - (second[1]["score"] if second else 0)
+    if gap >= 20 and top[1]["score"] >= 30:
+        conf = "높음"
+    elif gap >= 10 and top[1]["score"] >= 20:
+        conf = "중��"
+    else:
+        conf = "낮음"
+
+    return {
+        "model": top[0],
+        "confidence": conf,
+        "score": top[1]["score"],
+        "reasons": top[1]["reasons"],
+        "detail": evidence,
+        "ranked": ranked
+    }
+
 # ═══════════════════════════════════════════════
 # 품질
 # ═══════════════════════════════════════════════
@@ -835,30 +1112,40 @@ AI확률: 75%
 # ═══════════════════════════════════════════════
 # 종합 판정 (일관된 기준)
 # ═══════════════════════════════════════════════
-def compute_verdict(scores, llm_score=-1, sent_avg=-1):
-    w={"통계":.08,"문체":.30,"반복성":.12,"구조":.15,"지문":.35}
+def compute_verdict(scores, llm_score=-1, sent_avg=-1, ppx_score=-1, hum_score=-1):
+    w={"통계":.06,"문체":.25,"반복성":.10,"구조":.12,"지문":.30}
     ws=sum(scores[k]*w[k] for k in w)
 
-    # ★ 교차 신호 부스트 — 문체/지문 중심
-    style = scores["문체"]; fp = scores["지문"]; rep = scores["반복성"]; struct = scores["구조"]
-    if style >= 35 and fp >= 35: ws += 8  # 문체+지문 동시 → 강한 AI 신호
-    elif style >= 30 and fp >= 25: ws += 4
-    if style >= 30 and rep >= 25 and fp >= 20: ws += 4  # 3축 약신호
-    if fp >= 45: ws += 3  # 강한 지문 단독 부스트
-    if struct >= 50 and style >= 30: ws += 3  # 추상적+격식 문체
+    # ★ Perplexity 축 통합 (17%)
+    if ppx_score >= 0: ws += ppx_score * 0.17
+
+    # ★ 교차 신호 부스트
+    style=scores["문체"]; fp=scores["지문"]; rep=scores["반복성"]; struct=scores["구조"]
+    if style>=35 and fp>=35: ws+=8
+    elif style>=30 and fp>=25: ws+=4
+    if style>=30 and rep>=25 and fp>=20: ws+=4
+    if fp>=45: ws+=3
+    if struct>=50 and style>=30: ws+=3
+    # Perplexity + 지문 동시 부스트
+    if ppx_score>=55 and fp>=35: ws+=5
+    if ppx_score>=65 and style>=35: ws+=3
 
-    # ★ 문장 수준 부스트 (끌어내리지 않음)
-    if sent_avg >= 0 and sent_avg > ws:
-        ws = ws * 0.80 + sent_avg * 0.20
+    # ★ Humanizer 탐지 시 특별 부스트
+    if hum_score>=50:
+        ws=max(ws, 45)  # Humanizer 확인 → 최소 AI 의심 중간
+        ws += (hum_score-50)*0.15
+
+    # ★ 문장 수준 부스트
+    if sent_avg>=0 and sent_avg>ws: ws=ws*0.80+sent_avg*0.20
 
     hi=sum(1 for v in scores.values() if v>=50)
     if hi>=4: ws+=8
     elif hi>=3: ws+=5
     elif hi>=2: ws+=2
 
-    # ★ 인간 격식문 할인 — 지문이 낮고 구조가 구체적(낮은)인 경우만
-    if style < 40 and fp <= 20 and rep < 22 and struct < 35:
-        ws -= 5  # 격식이지만 AI 지문 없고 구체적 = 인간
+    # ★ 인간 격식문 할인
+    if style<40 and fp<=20 and rep<22 and struct<35 and (ppx_score<0 or ppx_score<40):
+        ws-=5
 
     lo=sum(1 for v in scores.values() if v<20)
     if lo>=3: ws-=8
@@ -876,10 +1163,12 @@ def quick_score(text):
     sc={"통계":analyze_statistics(text,sents,words)["score"],"문체":analyze_korean_style(text,sents,morphs)["score"],
         "반복성":analyze_repetition(text,sents,words)["score"],"구조":analyze_structure(text,sents)["score"],
         "지문":analyze_model_fingerprint(text,sents)["score"]}
-    # 문장 수준 평균 계산
-    sent_scores = [score_sentence(s)[0] for s in sents]
-    sent_avg = sum(sent_scores)/len(sent_scores) if sent_scores else -1
-    fs,v,lv=compute_verdict(sc, sent_avg=sent_avg); return fs,v,lv,sc
+    sent_scores=[score_sentence(s)[0] for s in sents]
+    sent_avg=sum(sent_scores)/len(sent_scores) if sent_scores else -1
+    ppx=analyze_perplexity(text,sents,morphs)
+    hum=analyze_humanizer(text,sents,words,morphs)
+    fs,v,lv=compute_verdict(sc, sent_avg=sent_avg, ppx_score=ppx["score"], hum_score=hum["score"])
+    return fs,v,lv,sc,ppx,hum
 
 # ═══════════════════════════════════════════════
 # ═══════════════════════════════════════════════
@@ -1433,26 +1722,41 @@ def run_detection(text, progress=gr.Progress()):
     if not text or len(text.strip())<50: return "<div style='padding:20px;text-align:center;color:#888;'>⚠️ 최소 50자</div>",""
     text=text.strip()
     progress(0.05); sents=split_sentences(text); words=split_words(text); morphs=get_morphemes(text)
-    progress(0.15); s1=analyze_statistics(text,sents,words)
-    progress(0.28); s2=analyze_korean_style(text,sents,morphs)
-    progress(0.38); s3=analyze_repetition(text,sents,words)
-    progress(0.48); s4=analyze_structure(text,sents)
-    progress(0.55); s5=analyze_model_fingerprint(text,sents)
-    progress(0.62); qr=analyze_quality(text,sents,words,morphs)
+    progress(0.12); s1=analyze_statistics(text,sents,words)
+    progress(0.22); s2=analyze_korean_style(text,sents,morphs)
+    progress(0.30); s3=analyze_repetition(text,sents,words)
+    progress(0.38); s4=analyze_structure(text,sents)
+    progress(0.45); s5=analyze_model_fingerprint(text,sents)
+    progress(0.52); ppx=analyze_perplexity(text,sents,morphs)
+    progress(0.58); hum=analyze_humanizer(text,sents,words,morphs)
+    progress(0.65); qr=analyze_quality(text,sents,words,morphs)
     progress(0.75); lr=llm_cross_check(text)
     sc={"통계":s1["score"],"문체":s2["score"],"반복성":s3["score"],"구조":s4["score"],"지문":s5["score"]}
-    # 문장별 점수 (탭2와 동일 기준)
-    sent_scores = [score_sentence(s)[0] for s in sents]
-    sent_avg = sum(sent_scores)/len(sent_scores) if sent_scores else -1
-    fs,verdict,level=compute_verdict(sc,lr["score"],sent_avg=sent_avg)
+    sent_scores=[score_sentence(s)[0] for s in sents]
+    sent_avg=sum(sent_scores)/len(sent_scores) if sent_scores else -1
+
+    # ★ 모델 추정
+    ms_raw=s5.get("model_scores",{})
+    model_est=estimate_model(text,sents,morphs,ms_raw)
+
+    fs,verdict,level=compute_verdict(sc,lr["score"],sent_avg=sent_avg,ppx_score=ppx["score"],hum_score=hum["score"])
     progress(0.95)
     cm={"ai_high":("#FF4444","#FFE0E0","높음"),"ai_medium":("#FF8800","#FFF0DD","중간~높음"),"ai_low":("#DDAA00","#FFFBE0","중간"),"uncertain":("#888","#F0F0F0","낮음"),"human":("#22AA44","#E0FFE8","매우 낮음")}
     fg,bg,conf=cm.get(level,("#888","#F0F0F0","?"))
-    ms=s5.get("model_scores",{}); tm=max(ms,key=ms.get) if ms else "N/A"; tms=ms.get(tm,0)
-    mt=f"{tm} ({tms}점)" if tms>=15 else "특정 불가"
 
-    ai_sents = sum(1 for s in sent_scores if s >= 40)
-    human_sents = sum(1 for s in sent_scores if s < 20)
+    # 모델 추정 표시
+    est_model=model_est.get("model","특정 불가")
+    est_conf=model_est.get("confidence","낮음")
+    est_reasons=model_est.get("reasons",[])
+    if est_model!="특정 불가" and est_conf!="낮음":
+        mt=f"{est_model} (신뢰: {est_conf})"
+    elif est_model!="특정 불가":
+        mt=f"{est_model} (참고)"
+    else:
+        mt="특정 불가"
+
+    ai_sents=sum(1 for s in sent_scores if s>=40)
+    human_sents=sum(1 for s in sent_scores if s<20)
 
     def gb(l,s,w="",desc=""):
         c="#FF4444" if s>=70 else "#FF8800" if s>=50 else "#DDAA00" if s>=35 else "#22AA44"
@@ -1460,15 +1764,20 @@ def run_detection(text, progress=gr.Progress()):
         dt=f"<div style='font-size:9px;color:#888;margin-top:1px;'>{desc}</div>" if desc else ""
         return f"<div style='margin:4px 0;'><div style='display:flex;justify-content:space-between;'><span style='font-size:11px;font-weight:600;'>{l}{wt}</span><span style='font-size:11px;font-weight:700;color:{c};'>{s}</span></div><div style='background:#E8E8E8;border-radius:4px;height:7px;'><div style='background:{c};height:100%;width:{s}%;border-radius:4px;'></div></div>{dt}</div>"
 
+    # 모델 지문 바
     mb=""
     for mn in ["GPT","Claude","Gemini","Perplexity"]:
-        s=ms.get(mn,0); mc="#FF4444" if s>=40 else "#FF8800" if s>=20 else "#CCC"
-        mb+=f"<div style='display:flex;align-items:center;gap:4px;margin:2px 0;'><span style='width:60px;font-size:10px;font-weight:600;'>{mn}</span><div style='flex:1;background:#E8E8E8;border-radius:3px;height:5px;'><div style='background:{mc};height:100%;width:{s}%;'></div></div><span style='font-size:9px;width:18px;text-align:right;color:{mc};'>{s}</span></div>"
+        s=ms_raw.get(mn,0); mc="#FF4444" if s>=40 else "#FF8800" if s>=20 else "#CCC"
+        # 추정 모델 표시
+        tag=""
+        if mn==est_model and est_conf!="낮음":
+            tag=f" <span style='background:#FF4444;color:white;font-size:7px;padding:0 3px;border-radius:3px;'>추정</span>"
+        mb+=f"<div style='display:flex;align-items:center;gap:4px;margin:2px 0;'><span style='width:66px;font-size:10px;font-weight:600;'>{mn}{tag}</span><div style='flex:1;background:#E8E8E8;border-radius:3px;height:5px;'><div style='background:{mc};height:100%;width:{s}%;'></div></div><span style='font-size:9px;width:18px;text-align:right;color:{mc};'>{s}</span></div>"
 
     # LLM 섹션
     ls=""
     if lr["score"]>=0:
-        lsc=lr["score"]; lc="#FF4444" if lsc>=70 else "#FF8800" if lsc>=50 else "#22AA44"
+        lsc=lr["score"]
         lr_rows="".join(f"<div style='font-size:9px;color:#555;'>{mn}: {lr['detail'].get(mn,'—')}</div>" for _,mn in LLM_JUDGES)
         ls=f"<div style='margin-top:8px;padding:8px;background:#F8F8FF;border-radius:6px;border:1px solid #E0E0FF;'><div style='font-size:10px;font-weight:700;margin-bottom:3px;'>🤖 LLM 교차검증 (평균 {lsc}%)</div>{lr_rows}</div>"
     else: ls="<div style='margin-top:6px;padding:4px 8px;background:#F5F5F5;border-radius:4px;color:#999;font-size:9px;'>🤖 GROQ_API_KEY 미설정</div>"
@@ -1479,20 +1788,62 @@ def run_detection(text, progress=gr.Progress()):
         c="#22AA44" if s>=70 else "#4ECDC4" if s>=55 else "#DDAA00" if s>=40 else "#FF8800"
         return f"<div style='margin:2px 0;display:flex;align-items:center;gap:4px;'><span style='width:50px;font-size:10px;'>{l}</span><div style='flex:1;background:#E8E8E8;border-radius:3px;height:5px;'><div style='background:{c};height:100%;width:{s}%;'></div></div><span style='font-size:9px;color:{c};width:18px;text-align:right;'>{s}</span></div>"
 
-    # 판정 이유 설명
-    reasons = []
-    if sc["문체"] >= 70: reasons.append("격식체 종결어미가 대부분, AI형 접속사·상투표현 다수 감지")
-    elif sc["문체"] >= 50: reasons.append("격식체와 AI형 표현이 혼재")
-    if sc["통계"] >= 70: reasons.append("문장 길이가 매우 균일하여 기계적 패턴")
-    elif sc["통계"] >= 50: reasons.append("문장 길이 변동성이 낮음")
-    if sc["반복성"] >= 50: reasons.append("문두 접속사 반복, n-gram 패턴 감지")
-    if sc["구조"] >= 50: reasons.append("리스트/마크다운 등 구조적 서식 사용")
-    if tms >= 20: reasons.append(f"{tm} 모델의 특징적 표현 감지")
+    # ★ 판정 이유 (3대 킬러 통합)
+    reasons=[]
+    if sc["문체"]>=70: reasons.append("격식체 종결어미가 대부분, AI형 접속사·상투표현 다수 감지")
+    elif sc["문체"]>=50: reasons.append("격식체와 AI형 표현이 혼재")
+    if ppx["score"]>=65: reasons.append(f"텍스트 예측 가능도가 매우 높음 (Perplexity {ppx['score']}점)")
+    elif ppx["score"]>=50: reasons.append(f"텍스트 예측 가능도가 높음 (Perplexity {ppx['score']}점)")
+    if hum["score"]>=50:
+        hum_sigs=", ".join(s[0] for s in hum["signals"][:3])
+        reasons.append(f"⚠️ Humanizer/패러프레이즈 흔적 감지 ({hum_sigs})")
+    if sc["통계"]>=60: reasons.append("문장 길이가 매우 균일하여 기계적 패턴")
+    if sc["반복성"]>=50: reasons.append("문두 접속사 반복, n-gram 패턴 감지")
+    if sc["구조"]>=50: reasons.append("추상적 수식어 다수, 구체적 사실 부족")
+    if est_model!="특정 불가" and est_conf!="낮음":
+        est_why=", ".join(est_reasons[:2]) if est_reasons else ""
+        reasons.append(f"🔍 추정 모델: <b>{est_model}</b> ({est_why})")
     if not reasons: reasons.append("인간적 표현이 우세하며 AI 패턴이 약함")
-    reason_html = '<br>'.join(f"• {r}" for r in reasons)
+    reason_html='<br>'.join(f"• {r}" for r in reasons)
+
+    # ★ Perplexity 카드
+    ppx_c="#FF4444" if ppx["score"]>=65 else "#FF8800" if ppx["score"]>=50 else "#DDAA00" if ppx["score"]>=35 else "#22AA44"
+    ppx_html=f"""<div style='margin-top:8px;padding:8px;background:linear-gradient(135deg,#FFF8F0,#FFF0FF);border-radius:6px;border:1px solid #E8D0FF;'>
+        <div style='font-size:10px;font-weight:700;margin-bottom:4px;'>🧠 Perplexity 분석 <span style='color:{ppx_c};font-size:12px;font-weight:900;'>{ppx["score"]}점</span></div>
+        <div style='display:grid;grid-template-columns:1fr 1fr;gap:2px;'>
+            <span style='font-size:9px;color:#777;'>엔트로피: {ppx.get("entropy",0)}</span>
+            <span style='font-size:9px;color:#777;'>분산균일: {ppx.get("variance",0)}</span>
+            <span style='font-size:9px;color:#777;'>어순예측: {ppx.get("order",0)}</span>
+            <span style='font-size:9px;color:#777;'>Zipf적합: {ppx.get("zipf",0)}</span>
+        </div>
+    </div>"""
+
+    # ★ Humanizer 탐지 카드
+    hum_html=""
+    if hum["score"]>=30:
+        hc="#FF4444" if hum["score"]>=65 else "#FF8800" if hum["score"]>=50 else "#DDAA00"
+        sig_rows="".join(f"<div style='font-size:9px;color:#555;'>🔸 {s[0]}: {s[2]}</div>" for s in hum["signals"][:4])
+        hum_html=f"""<div style='margin-top:8px;padding:8px;background:linear-gradient(135deg,#FFF0F0,#FFF5F0);border-radius:6px;border:1px solid #FFD0D0;'>
+            <div style='font-size:10px;font-weight:700;margin-bottom:3px;'>🛡️ Humanizer 탐지 <span style='color:{hc};font-size:12px;font-weight:900;'>{hum["score"]}점</span></div>
+            {sig_rows}
+        </div>"""
+
+    # ★ 모델 추정 카드
+    est_html=""
+    if est_model!="특정 불가":
+        ec="#FF4444" if est_conf=="높음" else "#FF8800" if est_conf=="중간" else "#DDAA00"
+        ranked_html=""
+        for m, ev in model_est.get("ranked",[])[:4]:
+            ms_c="#FF4444" if ev["score"]>=30 else "#FF8800" if ev["score"]>=15 else "#CCC"
+            bar_w=min(100,int(ev["score"]*1.5))
+            ranked_html+=f"<div style='display:flex;align-items:center;gap:4px;margin:1px 0;'><span style='width:55px;font-size:9px;font-weight:600;'>{m}</span><div style='flex:1;background:#E8E8E8;border-radius:3px;height:4px;'><div style='background:{ms_c};height:100%;width:{bar_w}%;border-radius:3px;'></div></div><span style='font-size:8px;color:{ms_c};'>{ev['score']:.0f}</span></div>"
+        est_html=f"""<div style='margin-top:8px;padding:8px;background:linear-gradient(135deg,#F0F8FF,#F0FFF0);border-radius:6px;border:1px solid #D0E8FF;'>
+            <div style='font-size:10px;font-weight:700;margin-bottom:3px;'>🎯 AI 모델 추정: <span style='color:{ec};font-size:12px;font-weight:900;'>{est_model}</span> <span style='font-size:9px;color:#888;'>(신뢰: {est_conf})</span></div>
+            {ranked_html}
+            <div style='font-size:8px;color:#999;margin-top:2px;'>근거: {", ".join(est_reasons[:3]) if est_reasons else "복합 지표"}</div>
+        </div>"""
 
     html=f"""<div style="font-family:'Pretendard','Noto Sans KR',sans-serif;max-width:720px;margin:0 auto;">
-        <!-- 판정 카드 -->
         <div style="background:{bg};border:2px solid {fg};border-radius:14px;padding:20px;margin-bottom:12px;">
             <div style="display:flex;align-items:center;gap:16px;">
                 <div style="text-align:center;min-width:100px;">
@@ -1516,12 +1867,13 @@ def run_detection(text, progress=gr.Progress()):
 
         <div style="display:grid;grid-template-columns:1fr 1fr;gap:8px;">
             <div style="background:#FAFAFA;border-radius:8px;padding:10px;">
-                <div style="font-size:10px;font-weight:700;margin-bottom:4px;">📊 AI 탐지 5축</div>
-                {gb('① 통계',sc['통계'],'.25','문장 길이 균일도·엔트로피')}
-                {gb('② 문체',sc['문체'],'.30','격식체·접속사·상투표현')}
-                {gb('③ 반복',sc['반복성'],'.15','n-gram·문두 반복')}
-                {gb('④ 구조',sc['구조'],'.15','문단·리스트·서식')}
-                {gb('⑤ 지문',sc['지문'],'.15','GPT/Claude/Gemini 특징')}
+                <div style="font-size:10px;font-weight:700;margin-bottom:4px;">📊 AI 탐지 5축 + Perplexity</div>
+                {gb('① 통계',sc['통계'],'.06','Burstiness·복잡도 균일성')}
+                {gb('② 문체',sc['문체'],'.25','격식·접속사·양보구문')}
+                {gb('③ 반복',sc['반복성'],'.10','n-gram·문두·종결다양성')}
+                {gb('④ 구조',sc['구조'],'.12','추상성/구체성')}
+                {gb('⑤ 지문',sc['지문'],'.30','GPT/Claude/Gemini/PPX')}
+                {gb('⑥ PPX',ppx['score'],'.17','예측가능도·엔트로피')}
             </div>
             <div style="background:#FAFAFA;border-radius:8px;padding:10px;">
                 <div style="font-size:10px;font-weight:700;margin-bottom:4px;">🔍 모델 지문</div>
@@ -1535,9 +1887,9 @@ def run_detection(text, progress=gr.Progress()):
                 </div>
             </div>
         </div>
-        {ls}
+        {ppx_html}{hum_html}{est_html}{ls}
     </div>"""
-    log=f"AI:{fs}점 [{verdict}] 신뢰:{conf} | 모델:{mt} | 품질:{qr['grade']}({qr['score']})\n축: 통계{sc['통계']} 문체{sc['문체']} 반복{sc['반복성']} 구조{sc['구조']} 지문{sc['지문']}"
+    log=f"AI:{fs}점 [{verdict}] 신뢰:{conf} | 모델:{mt} | PPX:{ppx['score']} HUM:{hum['score']} | 품질:{qr['grade']}({qr['score']})\n축: 통계{sc['통계']} 문체{sc['문체']} 반복{sc['반복성']} 구조{sc['구조']} 지문{sc['지문']} PPX{ppx['score']} HUM{hum['score']}"
     return html, log
 
 # ═══════════════════════════════════════════════
@@ -1630,7 +1982,7 @@ def run_document_analysis(file, progress=gr.Progress()):
     sents_all = split_sentences(full_text)
     words_all = split_words(full_text)
     morphs_all = get_morphemes(full_text)
-    total_score, total_verdict, total_level, total_axes = quick_score(full_text)
+    total_score, total_verdict, total_level, total_axes, total_ppx, total_hum = quick_score(full_text)
     quality = analyze_quality(full_text, sents_all, words_all, morphs_all)
 
     # LLM 교차검증 (전체)
@@ -1639,7 +1991,7 @@ def run_document_analysis(file, progress=gr.Progress()):
     if llm_result["score"] >= 0:
         _sent_scores = [score_sentence(s)[0] for s in sents_all]
         _sent_avg = sum(_sent_scores)/len(_sent_scores) if _sent_scores else -1
-        total_score, total_verdict, total_level = compute_verdict(total_axes, llm_result["score"], sent_avg=_sent_avg)
+        total_score, total_verdict, total_level = compute_verdict(total_axes, llm_result["score"], sent_avg=_sent_avg, ppx_score=total_ppx["score"], hum_score=total_hum["score"])
 
     # 섹션별 분석
     progress(0.45, f"{len(sections)}개 섹션 분석...")
@@ -1648,7 +2000,7 @@ def run_document_analysis(file, progress=gr.Progress()):
         if len(sec.strip()) < 20:
             section_results.append({"idx": i+1, "text": sec, "score": -1, "verdict": "너무 짧음", "skipped": True})
             continue
-        s_score, s_verdict, s_level, s_axes = quick_score(sec)
+        s_score, s_verdict, s_level, s_axes, _, _ = quick_score(sec)
         # 문장별 하이라이트
         sec_sents = split_sentences(sec)
         sent_scores = []