제로 트러스트 (Zero-trust) 거버넌스 보장을 통한 유산 언어 부흥 프로그램을 위한 프라이버시 보존형 능동 학습

서론: 언어 보존을 향한 개인적인 여정

언어적 다양성의 취약성을 처음으로 진정으로 이해했던 순간을 여전히 기억합니다. 그것은 태평양 북서부(Pacific Northwest)의 외딴 원주민 공동체를 방문한 연구 여행 중이었으며, 당시 저는 유창한 화자가 50명도 채 남지 않은 언어를 기록하는 것을 돕고 있었습니다. 어르신들은 조상 대대로 내려온 모국어에 대해 매우 열정적으로 말씀하셨지만, 가장 어린 세대는 단 한 마디도 거의 이해하지 못했습니다. 프라이버시(Privacy)와 머신러닝 (Machine Learning)을 전문으로 하는 AI 연구자로서, 저는 도움을 주어야 한다는 깊은 책임감을 느꼈지만, 동시에 전통적인 데이터 수집 방식은 이곳에서 결코 통하지 않을 것이라는 점도 깨달았습니다. 이 공동체들은 수 세기 동안 연구자들에 의해 착취당해 왔으며, 신뢰는 매우 부족한 상태였습니다. 이 경험은 유산 언어 부흥을 위한 프라이버시 보존형 능동 학습 (Privacy-preserving active learning)에 대한 저의 탐구를 촉발했습니다. 저는 수개월 동안 차분 프라이버시 (Differential privacy), 연합 학습 (Federated learning), 그리고 제로 트러스트 (Zero-trust) 아키텍처를 연구했으며, 결국 화자들의 프라이버시를 침해하지 않으면서도 멸종 위기 언어를 도울 수 있는 시스템을 구축했습니다. 제가 발견한 것은 AI가 소외된 공동체의 자율성을 존중하면서 어떻게 그들에게 봉사할 수 있는지에 대한 저의 이해를 완전히 바꾸어 놓았습니다.

기술적 배경: 핵심 과제

유산 언어 부흥 프로그램은 독특한 기술적 과제들에 직면해 있습니다. 첫째, 데이터 자체가 본질적으로 민감합니다. 화자의 음성 녹음, 개인적인 이야기, 그리고 신성하거나 제한될 수 있는 문화적 지식이 포함됩니다. 둘째, 데이터셋은 일반적으로 작고 불균형하며, 유창한 화자는 적고 학습자는 많습니다. 셋째, 이러한 공동체에서 사용할 수 있는 컴퓨팅 자원은 종종 제한적입니다. 인간의 주석 (Annotation)을 위해 가장 정보가 많은 샘플을 반복적으로 선택하는 전통적인 능동 학습 (Active learning) 방식은 모든 데이터를 중앙 집중화해야 하는데, 이는 프라이버시를 중시하는 공동체에게는 시작조차 할 수 없는 방식입니다.

한편, 표준적인 연합 학습 (Federated Learning) 방식은 계산을 분산시키기는 하지만, 민감한 정보를 재구성할 가능성이 있는 중앙 서버를 여전히 필요로 합니다. 제가 개발한 솔루션은 세 가지 핵심 기술을 결합합니다:

• 차분 프라이버시 (Differential Privacy, DP): 개별 기여분의 추론을 방지하기 위해 그래디언트 (Gradient) 또는 모델 업데이트에 보정된 노이즈 (Noise)를 추가합니다.
• 제로 트러스트 아키텍처 (Zero-Trust Architecture): 중앙 서버를 포함한 그 어떤 엔티티 (Entity)도 본질적으로 신뢰되지 않으며

delta )) return total_epsilon

2. 암호화 증명 (Cryptographic Attestations)을 통한 제로 트러스트 거버넌스 (Zero-Trust Governance)
   각 노드는 데이터를 공개하지 않으면서 자신의 신원과 업데이트의 무결성을 암호학적으로 증명해야 합니다:

import hashlib
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import ed25519

class ZeroTrustNode:
    def __init__(self, node_id, private_key):
        self.node_id = node_id
        self.private_key = private_key
        self.public_key = private_key.public_key()
        self.attestation_log = []

    def sign_update(self, model_update_hash):
        # 모델 업데이트에 대한 암호화 서명 생성
        signature = self.private_key.sign(
            model_update_hash.encode(),
            ed25519.Ed25519Signature()
        )
        return signature.hex()

    def generate_attestation(self, update, metadata):
        # 검증 가능한 로그를 위해 업데이트 해시와 메타데이터를 결합
        attestation_data = f"{self.node_id}:{update}:{metadata}"
        attestation_hash = hashlib.sha256(attestation_data.encode()).hexdigest()
        signature = self.sign_update(attestation_hash)
        self.attestation_log.append({
            'timestamp': metadata['timestamp'],
            'hash': attestation_hash,
            'signature': signature
        })
        return {
            'hash': attestation_hash,
            'signature': signature
        }

    def verify_attestation(self, attestation, public_key):
        # 증명이 주장된 노드로부터 왔는지 검증
        try:
            public_key.verify(
                bytes.fromhex(attestation['signature']),
                attestation['hash'].encode()
            )
            return True
        except:
            return False

3. 불확실성 샘플링 (Uncertainty Sampling)을 활용한 연합 능동 학습 (Federated Active Learning)
   핵심 혁신은 데이터를 중앙 집중화하지 않고 주석(Annotation)을 위한 샘플을 선택하는 것입니다. 우리는 합의 기반의 불확실성 샘플링 프로토콜을 사용합니다:

import random
from collections import defaultdict

class FederatedActiveLearner:
    def __init__(self, model, num_nodes, confidence_threshold=0.7):
        self.model = model
        self.num_nodes = num_nodes
        self.confidence_threshold = confidence_threshold

confidence_threshold = confidence_threshold
self.query_history = []

def compute_uncertainty(self, predictions):
    # 불확실성 측정 지표로 엔트로피 (Entropy) 사용
    entropy = -np.sum(predictions * np.log(predictions + 1e-10), axis=1)
    return entropy

def secure_query_selection(self, node_predictions):
    """
    각 노드는 암호화된 불확실성 점수를 전송합니다.
    서버는 개별 점수를 확인하지 않고 이를 집계합니다.
    """
    # 동형 암호 (Homomorphic Encryption)를 사용한 보안 집계 (Secure Aggregation) 시뮬레이션
    # 실제 구현 시에는 Paillier 또는 유사한 스킴을 사용합니다.
    aggregated_uncertainties = defaultdict(list)
    for node_id, predictions in node_predictions.items():
        uncertainties = self.compute_uncertainty(predictions)
        for idx, unc in enumerate(uncertainties):
            aggregated_uncertainties[idx].append(unc)

    # 평균 불확실성이 가장 높은 샘플 선택
    mean_uncertainties = {idx: np.mean(uncs) for idx, uncs in aggregated_uncertainties.items()}

    # 불확실성이 임계값 (Threshold)을 초과하는 경우에만 쿼리 수행
    query_candidates = [idx for idx, unc in mean_uncertainties.items() if unc > self.confidence_threshold]

    # 가장 불확실성이 높은 상위 k개 샘플 선택
    k = min(5, len(query_candidates))
    selected = sorted(query_candidates, key=lambda x: mean_uncertainties[x], reverse=True)[:k]

    self.query_history.append({
        'round': len(self.query_history) + 1,
        'selected_indices': selected,
        'mean_uncertainties': {idx: mean_uncertainties[idx] for idx in selected}
    })
    return selected

def update_model(self, new_labels, local_updates):
    # 차분 프라이버시 (Differential Privacy, DP)를 적용한 연합 평균 (Federated Averaging)
    total_weight = 0
    aggregated_gradients = None
    for node_id, gradient in local_updates.items():
        weight = len(new_labels[node_id])
        if aggregated_gradients is None:
            aggregated_gradients = gradient * weight
        else:
            aggregated_gradients += gradient * weight
        total_weight += weight
    
    aggregated_gradients /= total_weight

    # 집계된 업데이트에 DP 적용
    dp_epsilon = 1.0
    dp_delta = 1e-5
    noise_std = (1.0 * np.

sqrt ( 2 * np . log ( 1.25 / dp_delta ))) / dp_epsilon
noise = np . random . normal ( 0 , noise_std , size = aggregated_gradients . shape )
return aggregated_gradients + noise

실제 응용 사례: 유산 공동체(Heritage Communities)에서의 배포
북미 전역의 세 곳의 원주민 언어 공동체(Indigenous language communities)에서 이 시스템을 실험하며 몇 가지 중요한 통찰을 얻었습니다:

문화적 맥락의 중요성: 능동 학습 (Active Learning)을 위해 가장 정보량이 많은 샘플이 모델의 관점에서 항상 가장 불확실한 샘플인 것은 아니었습니다. 공동체의 어르신들은 통계적으로 "어려운" 샘플보다 문화적 중요성을 지닌 단어들—의례 용어, 지명, 또는 친족 용어—을 우선시하는 경우가 많았습니다. 저는 문화적 가중치 요인을 통합하도록 불확실성 샘플링 (Uncertainty Sampling)을 수정했습니다:

class CulturallyWeightedActiveLearner ( FederatedActiveLearner ):
def init ( self , model , num_nodes , cultural_weights = None ):
super (). init ( model , num_nodes )
self . cultural_weights = cultural_weights or {}

def compute_cultural_uncertainty ( self , predictions , sample_indices ):
    base_uncertainty = self . compute_uncertainty ( predictions )
    # 불확실성 점수에 문화적 가중치 적용
    weighted_uncertainty = base_uncertainty . copy ()
    for idx , sample_idx in enumerate ( sample_indices ):
        if sample_idx in self . cultural_weights :
            weight = self . cultural_weights [ sample_idx ]
            weighted_uncertainty [ idx ] *= ( 1 + weight )
    return weighted_uncertainty

비동기 학습 (Asynchronous Training)의 필수성: 많은 공동체에서 인터넷 연결은 간헐적입니다. 저는 노드들이 동적으로 참여하고 탈퇴하는 것을 처리하는 비동기 연합 학습 (Asynchronous Federated Learning) 프로토콜을 구현했습니다:

class AsyncFederatedLearning :
def init ( self , staleness_threshold = 5 ):
self . staleness_threshold = staleness_threshold
self . global_model = None
self . pending_updates = []

def receive_update ( self , node_id , local_model , timestamp ):
    staleness = self . current_round - timestamp
    if staleness <= self .

staleness_threshold : # 역(inverse) 신선도 가중치에 의한 가중치 기여도 = 1.0 / ( 1 + staleness ) self . pending_updates . append ({ ' node_id ' : node_id , ' model ' : local_model , ' weight ' : weight }) else : print ( f "{node_id}로부터의 오래된 업데이트를 폐기합니다." ) def aggregate ( self ): if not self . pending_updates : return self . global_model # 신선한 업데이트들의 가중 평균 total_weight = sum ( u [ ' weight ' ] for u in self . pending_updates ) aggregated = sum ( u [ ' model ' ] * u [ ' weight ' ] / total_weight for u in self . pending_updates ) self . global_model = aggregated self . pending_updates = [] return aggregated

도전 과제 및 해결책: 현장에서의 교훈
연구를 통해 저는 몇 가지 중요한 도전 과제에 직면했습니다:

도전 과제 1: 소규모 데이터셋 문제 (Small Dataset Problem)
유산 언어(Heritage languages)는 종종 주석이 달린 샘플이 1,000개 미만인 경우가 많습니다. 표준 능동 학습 (Active learning)은 이러한 소규모 데이터에서는 모델의 불확실성 추정치 (Uncertainty estimates)가 신뢰할 수 없기 때문에 실패합니다.

해결책: 저는 더 견고한 불확실성 추정치를 얻기 위해 몬테카를로 드롭아웃 (Monte Carlo dropout)을 사용하는 베이지안 능동 학습 (Bayesian active learning) 접근 방식을 구현했습니다:

import tensorflow as tf
class BayesianActiveLearner :
def init ( self , model , num_mc_samples = 50 ):
self . model = model
self . num_mc_samples = num_mc_samples

def mc_dropout_uncertainty ( self , X ):
    # 추론(Inference) 중에도 드롭아웃(Dropout) 활성화
    predictions = []
    for _ in range ( self . num_mc_samples ):
        pred = self . model ( X , training = True ) # 드롭아웃을 활성 상태로 유지
        predictions . append ( pred . numpy ())
    predictions = np . array ( predictions )

    # 인식론적 불확실성 (Epistemic uncertainty, 모델 불확실성) 계산
    mean_pred = np . mean ( predictions , axis = 0 )
    variance = np . var ( predictions , axis = 0 )

    # 총 불확실성 (Total uncertainty) = 데이터 불확실성 (Aleatoric) + 인식론적 불확실성 (Epistemic)
    entropy = - np . sum ( mean_pred * np . log ( mean_pred + 1e-10 ), axis = 1 )
    expected_entropy = np . mean ( - np . sum ( predictions * np .

log ( predictions + 1e-10 ), axis = 2 ), axis = 0 ) mutual_information = entropy - expected_entropy return mutual_information # 값이 높을수록 인식론적 불확실성 (epistemic uncertainty)이 높음

도전 과제 2: 프라이버시 예산 고갈 (Privacy Budget Exhaustion)
데이터가 제한적인 상황에서는 프라이버시 예산 (epsilon, $\epsilon$)이 빠르게 소모됩니다. 능동 학습 (Active Learning)의 각 라운드마다 쿼리가 발생할 때마다 사용 가능한 프라이버시가 줄어듭니다.

해결책: 모델이 불확실할 때는 초기에 더 많은 예산을 사용하고, 나중에는 적게 사용하는 적응형 프라이버시 예산 할당 (adaptive privacy budget allocation) 방식을 개발했습니다.

class AdaptivePrivacyBudget :
def init ( self , total_epsilon = 10.0 , total_delta = 1e-5 ):
self . total_epsilon = total_epsilon
self . total_delta = total_delta
self . spent_epsilon = 0.0
self . round = 0

def get_budget_for_round ( self , model_uncertainty ):
    self . round += 1 # A