Training-Free Cultural Alignment of Large Language Models via Persona Disagreement

# DISCA 핵심 로직 스니펫 (단순화 버전)
import numpy as np
from scipy.special import softmax

def disca_correction(
    base_logit_gap: float,
    persona_logit_gaps: list[float],  # N=4 페르소나의 logit gap
    K_half: int = 64,
    sigma: float = 0.3,
    alpha: float = 0.88,
    kappa: float = 2.25,
    lambda_coop: float = 0.7,
    eta: float = 0.5,
    s: float = 0.04
) -> float:
    """
    DISCA 보정값 계산
    - base_logit_gap: 페르소나 없이 기본 프롬프트로 얻은 logit(B) - logit(A)
    - persona_logit_gaps: 4개 페르소나 프롬프트로 얻은 각각의 logit gap
    """
    N = len(persona_logit_gaps)
    delta_bar = np.mean(persona_logit_gaps)  # 컨센서스
    
    def prospect_value(z):
        """Kahneman-Tversky 가치 함수 (손실 회피)"""
        if z >= 0:
            return z ** alpha
        else:
            return -kappa * ((-z) ** alpha)
    
    def run_pt_is(k_samples):
        """Prospect Theory Importance Sampling 1회 실행"""
        epsilons = np.random.normal(0, sigma, k_samples)
        utilities = []
        for eps in epsilons:
            delta_candidate = delta_bar + eps
            # 각 페르소나의 gain 계산
            cohort_gains = [
                abs(base_logit_gap - pg) - abs(delta_candidate - pg)
                for pg in persona_logit_gaps
            ]
            cons_gain = abs(base_logit_gap - delta_bar) - abs(delta_candidate - delta_bar)
            # 손실 회피 유틸리티 집계
            u_cohort = np.mean([prospect_value(g / sigma) for g in cohort_gains])
            u_cons = prospect_value(cons_gain / sigma)
            u_total = (1 - lambda_coop) * u_cohort + lambda_coop * u_cons
            utilities.append(u_total)
        
        weights = softmax(np.array(utilities) / eta)
        return np.dot(weights, epsilons)
    
    # Dual-pass reliability gate
    correction_1 = run_pt_is(K_half)
    correction_2 = run_pt_is(K_half)
    
    # 두 패스의 불일치가 크면 보정 축소
    Vr = (correction_1 - correction_2) ** 2
    reliability = np.exp(-Vr / s)  # 불일치 클수록 0에 가까워짐
    
    final_correction = reliability * (correction_1 + correction_2) / 2
    return final_correction

# 사용 예시
base_gap = 0.2  # logit(B) - logit(A) without persona
persona_gaps = [0.5, 0.8, 0.3, 0.6]  # 4개 페르소나의 logit gap
correction = disca_correction(base_gap, persona_gaps)
steered_gap = base_gap + correction
print(f"보정 전 확률: {1/(1+np.exp(-base_gap/0.5)):.3f}")
print(f"보정 후 확률: {1/(1+np.exp(-steered_gap/0.5)):.3f}")