인공지능/논문 리뷰 or 진행

Privacy AI 관련 조사 2

이게될까 2025. 12. 2. 18:59

728x90

https://aclanthology.org/2022.naacl-main.231/

Privacy-Preserving Text Classification on BERT Embeddings with Homomorphic Encryption

Garam Lee, Minsoo Kim, Jai Hyun Park, Seung-won Hwang, Jung Hee Cheon. Proceedings of the 2022 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies. 2022.

aclanthology.org

Privacy-Preserving Text Classification on BERT Embeddings with Homomorphic Encryption

naacl 메인에 붙었네요...?

임베딩을 암호화한 상태에서 classification을 진행하여 정확도는 유지하면서도 임베딩의 유출이나 역복원 위험을 없애는 방법을 제안

그럼 이 방법론은 user의 컴퓨터에서 SentenceBERT를 통해 나온 Embedding을 암호화한뒤, 서버에 있는 컴퓨터에서 암호화한 embedding 을 받아들어서 regression을 진행한다는거야?
그럼 저 모델으 암호화된 임베딩을 받아들일 수 있어야 하는 거고?
그럼 암호화된 임베딩으로 학습되어야 하는거 아니야??

정확한 지점을 짚었고, 이 논문의 핵심을 명확히 이해하려면 “모델이 평문을 보지 못하는 HE 환경에서 어떻게 학습/추론을 가능하게 하는가?” 를 분해해서 보면 됩니다.

결론부터 말하면:

네, 사용자 단말에서 Sentence-BERT 임베딩을 만든 뒤 CKKS로 암호화해서 서버로 보내고,
서버는 “암호화된 임베딩” 위에서 그대로 로지스틱 회귀를 학습/추론합니다.
서버는 평문 임베딩을 전혀 보지 못합니다.

그리고

맞습니다. 로지스틱 회귀 모델 파라미터도 “암호화된 상태에서” 학습됩니다.

즉, 학습 데이터도 ciphertext, 모델 파라미터도 ciphertext이며, 학습 과정의 모든 중간 결과도 ciphertext입니다.
→ 서버는 절대 plaintext embedding을 보지 못합니다.

✔ 핵심 구조: “Ciphertext-only Logistic Regression”

논문의 파이프라인은 End-to-end HE 학습입니다.

1) 사용자 측(local)

SentenceBERT로 768-dim 임베딩 생성:
[
y = F_{\text{emb}}(x)
]
CKKS로 암호화:
[
\tilde{y} = H(y)
]
암호문(cyphertext)만 서버로 전송.

서버는 절대 (y) (평문 벡터)를 받지 않습니다.

✔ 그러면 서버는 어떻게 학습함? (가장 중요한 질문)

2) 서버 측

서버는 다음 연산을 모두 평문 없이, ciphertext로만 수행합니다.

(A) 모델 파라미터도 ciphertext 상태로 유지

로지스틱 회귀는 weight (w \in \mathbb{R}^{768}) 과 bias (b)를 가짐.
이 (w, b)도 암호화된 형태로 저장됨.

즉,
[
w \rightarrow \tilde{w}, \quad b \rightarrow \tilde{b}
]

(B) Forward: 암호화된 임베딩 × 암호화된 weight

로지스틱 회귀의 선형 부분:
[
z = w^\top y + b
]

HE 환경에서는:
[
\tilde{z} = \tilde{w}^\top \tilde{y} + \tilde{b}
]

→ CKKS는 덧셈/곱셈을 지원하므로 ciphertext-only로 계산 가능.

(C) Sigmoid / Logistic 근사도 ciphertext에서 계산

sigmoid는 HE에서 직접 못 쓰므로 15차 다항식으로 근사하여:

[
\sigma(z) \approx p_{15}(z)
]

CKKS는 다항식 연산은 문제 없이 수행 가능.
이 계산도 모두 ciphertext-only.

(D) Backward (Gradient)도 ciphertext-only

로지스틱 회귀의 gradient:

[
\nabla_w L = ( \sigma(z) - y_{\text{true}} ) y
]

이 연산 역시 모두 ciphertext 연산으로 치환됩니다.

논문에서

ciphertext linear 연산
ciphertext 다항식 연산
ciphertext scale 조정
ciphertext 부트스트래핑

을 조합해 SGD 업데이트까지 HE로 수행합니다.

(E) 최종 weight 또한 암호화 상태

모델 업데이트:
[
w \leftarrow w - \eta \nabla_w L
]

은 다음으로 수행:
[
\tilde{w} \leftarrow \tilde{w} - \eta \widetilde{\nabla_w L}
]

모델의 모든 학습 이력과 중간 파라미터는 평문이 되지 않습니다.

✔ 그렇다면 “학습은 HE 환경에서만 진행되는데, 왜 문제 없지?”

로지스틱 회귀는 linear 연산 + sigmoid 근사만 필요하고, sigmoid는 다항식으로 근사하면 되기 때문에 CKKS가 지원하는 연산 조합 내에 완전히 들어옵니다.

즉:

➤ 로지스틱 회귀는 HE에서 완전히 학습 가능

weight multiply
add
polynomial(sigmoid approximation)
SGD update

이 네 가지는 CKKS가 모두 지원하는 연산입니다.

➤ 복잡한 Deep Neural Network는 어려움

CNN/Transformer는 multiplicative depth가 너무 깊기 때문에 부트스트래핑 비용이 폭발합니다.
그래서 논문은 “embedding은 로컬에서 만들고, HE에서는 로지스틱 회귀만”이라는 전략을 택한 겁니다.

✔ 정리하면

Q1. user 단말에서 embedding을 만들고 암호화해서 서버로 보내는 게 맞아?

→ 맞습니다. 절대 평문 embedding이 서버에 전달되지 않습니다.

Q2. 서버의 모델은 암호화된 embedding을 받아들이는 구조여야 하는 거지?

→ 맞습니다. 서버는 plaintext 연산을 하지 못하며, 모든 계산은 ciphertext-only입니다.

Q3. 그럼 암호화된 embedding으로 학습되어야 하는 거야?

→ 정확합니다. 모델 파라미터 (w, b)도 ciphertext-only로 학습됩니다.

즉,

훈련 데이터도 암호화 / 파라미터도 암호화 / 추론도 암호화 / 결과만 복호화하는 HE-only logistic regression입니다.

✔ 그림 수준으로 구조 표현 (쉽게)

User(Local)

Text → SentenceBERT → Embedding y → CKKS.encrypt(y) = y~ → Send to Server

Server

Input: y~ (encrypted embedding)
Model: w~, b~ (encrypted parameters)

Compute:
    z~ = <w~, y~> + b~
    p~ = sigmoid_approx(z~)
    loss~ = ...
    grad~ = ...
    w~ = w~ - lr * grad~
    b~ = ...

Output: p~ (encrypted probability)

User(Local)

Decrypt p~ → p → Label

원하면,

이 구조를 수식 구조도로 그려주거나,
"왜 HE 환경에서 logistic regression만 가능한가",
"CKKS 부트스트래핑/레벨 설정이 실제 연산에 어떻게 영향을 주는가"
도 이어서 더 자세하게 설명해 줄 수 있습니다.

근데 결국 암호화된 임베딩도 학습할 정도로 많이 있으면 다시 복구할 수 있는거 아니야??

결론부터 명확하게 말하면:

이 논문에서 사용하는 CKKS 기반 동형암호(HE)에서는,
“암호화된 임베딩”을 아무리 많이 모아도 절대 역복원이 불가능합니다.

이유는 간단합니다.
서버가 가진 암호문(ciphertext)만으로는 어떠한 통계적·신경망 기반 공격도 수행할 수 없으며,
암호학적으로 plaintext에 대한 정보가 ‘0 bit’입니다.

이게 단순히 “공격이 어렵다” 수준이 아니라,
암호학적으로 정보이론적으로 불가능하다는 의미입니다.

아래에서 이 결론을 step-by-step으로 설명하겠습니다.

✔ 1. 동형암호에서 ciphertext를 많이 모아도 plaintext에 대한 정보가 없다는 이유

CKKS는 RLWE(Ring Learning With Errors) 문제 위에서 만들어진 암호 시스템입니다.
이는 다음 성질을 가집니다:

정보이론적 관점

Ciphertext (ct)는
[
ct = (a, b = a\cdot sk + m + e)
]
형태인데,
여기서 (sk)는 비밀키, (m)은 메시지, (e)는 가우시안 노이즈입니다.
공격자가 (a)와 (b)를 수천만 개 모아도,
[
b - a\cdot sk
]
에 남는 노이즈 (e) 때문에
plaintext(m)를 정확히 추론하는 것이 수학적으로 불가능합니다.

학습 기반 복구(ML inversion)도 원천적으로 불가능

왜냐하면:

ciphertext 공간은 의미 없는 난수 벡터의 공간
ciphertext 간의 유클리드 거리/각도가 plaintext와 아무 상관 없음
ciphertext는 homomorphic 연산으로만 조작 가능 (곱셈/덧셈),
내부 실제 값(plaintext)은 절대 노출 ❌

따라서:

딥러닝 기반 inversion 모델을 학습할 raw data(평문 임베딩)–ciphertext pair 자체가 존재하지 않습니다.

훈련이 불가능합니다.

✔ 2. "암호화된 임베딩을 많이 수집하면 패턴을 배울 수 있지 않을까?"에 대한 완전한 반증

❌ (반례 1) Ciphertext 간의 거리/패턴은 plaintext 구조를 반영하지 않음

CKKS ciphertext는 random noise + 모듈러 연산으로 구성되어 있어서

ciphertext끼리 “비슷해 보이는 것”과
plaintext가 비슷한 것

은 아무 관계가 없습니다.

즉, embedding space의 의미 구조(semantic structure)는 ciphertext space에서는 완전히 사라집니다.

→ 클러스터링, PCA, distance learning, metric learning 불가능

❌ (반례 2) 서버에는 plaintext label도 없음

HE 환경에서:

서버는 입력도 ciphertext,
weight도 ciphertext,
로짓도 ciphertext,
gradient도 ciphertext.

서버는 오직 ciphertext 연산만 수행합니다.

서버가 볼 수 있는 것은:

ct1: 임베딩 암호문
ct2: 파라미터 암호문
ct3: gradient 암호문
…

모든 값이 암호문입니다.
서버가 plaintext 벡터를 한 번도 보지 못하므로:

(plaintext embedding → label) 학습을 위한 정보가 존재하지 않고,
(ciphertext → plaintext embedding) mapping도 학습 불가.

❌ (반례 3) 암호문에 대해 "chosen-ciphertext attack"도 불가능

HE 시스템은 **semantic security under chosen plaintext attack (CPA-secure)**입니다.

즉,

공격자가 임의의 plaintext를 넣고 ciphertext를 보고 역추론하는 것도 불가능.

CPA-secure라는 것은 암호문의 분포가 랜덤 분포와 구분 불가능하다는 뜻입니다.

따라서 아래 공격이 모두 차단됩니다:

ciphertext clustering
ciphertext–plaintext regression
ciphertext similarity learning
ciphertext relationship modeling

✔ 3. 반대로 LDP(local differential privacy)는 왜 inversion이 가능한가?

논문 비교에서 나온 것처럼 Sentence-BERT + LDP는:

Sentence-BERT 임베딩 (y)
noise가 추가된 벡터 (y+N)

이라는 pair가 존재합니다.

이때 서버는 충분히 많이 모으면:

[
\mathbb{E}[y+N] = y
]

또는 모델 기반으로 (y)를 복원하는 공격이 가능합니다.

그래서 LDP 방법들은 inversion F1이 0.48 ~ 0.67까지 올라갑니다.

즉:

LDP는 “노이즈가 추가된 임베딩”을 보내므로
원래 임베딩(y)을 statistical estimation으로 접근 가능.

하지만 HE는 임베딩 자체가 완전히 보이지 않으며,
ciphertext는 임의의 랜덤 벡터와 구분 불가능합니다.

→ inversion이 원천적으로 불가능.

✔ 4. “그럼 학습 과정에서 gradient가 ciphertext로 오가는데, 그걸로 유추 가능한가?”

역추론 불가능합니다.

gradient도 ciphertext
loss도 ciphertext
update 결과도 ciphertext

서버는 오직

[
\tilde{w}_{t+1} = \tilde{w}_t - \eta \cdot \widetilde{\nabla L}
]

같은 조작만 할 수 있고,
여기서 (\tilde{w}, \widetilde{\nabla L})은 모두 난수 같은 ciphertext입니다.

ciphertext끼리의 관계만 보며 plaintext를 유추한다?
RSA나 AES와 마찬가지로 수학적으로 불가능합니다.

✔ 5. 결론적으로:

암호화된 임베딩을 많이 모아도 복구/학습/역추론은 완전히 불가능한 이유

암호학적 이유 + 기계학습적인 이유 두 가지가 동시에 적용됩니다.

🛡 암호학적 차원

CKKS ciphertext는 RLWE 기반 →
비밀키 없이 plaintext 계산 불가 (128-bit security 수준).
ciphertext는 randomness 때문에
동일한 plaintext를 넣어도 매번 다른 ciphertext 생성
→ ciphertext 간 비교 불가.
ciphertext는 semantic security (CPA-secure)
→ ciphertext만 보아서는 plaintext에 대한 정보가 0 bit.

🤖 기계학습 차원

ciphertext space는 “임베딩 공간의 의미 구조”를 보존하지 않음.
(ciphertext → plaintext) mapping을 학습할 수 있는 데이터가 없음.
label이나 gradient도 ciphertext이므로 학습 데이터 pair가 존재하지 않음.

따라서 ML 인버전 공격이 성립할 환경이 근본적으로 없음.

🔥 최종 요약

**LDP 방식은 “노이즈가 추가된 임베딩”이므로
충분한 데이터가 있으면 원래 임베딩을 일부 복원할 수 있다.

하지만 HE 방식에서는 서버가 단 한 번도 plaintext 임베딩을 본 적이 없으며,
ciphertext는 RLWE 기반 난수 분포라 ML/統計 공격이 절대 불가능하다.**

즉, 아무리 많은 암호화 임베딩을 수집해도 의미 있는 재구성은 절대 불가능하다.

원하면,

“Ciphertext 공간이 왜 semantic structure를 보존하지 않는가”
CKKS 안전성에 대한 수학적 인사이트
HE 기반 모델에서 가능한 공격과 불가능한 공격
도 더 깊게 설명해 줄게.

문제 상황	- BERT/Sentence-BERT 임베딩은 다운스트림 성능이 강력하지만 민감 속성 유출, embedding inversion 공격에 취약. - LDP(noise) 기반 보호 방식은 성능–프라이버시 트레이드오프가 심함. - 사용자는 텍스트 원본이나 임베딩을 서버에 보내지 않고도 분류 서비스를 받고 싶음. - 서버는 평문 임베딩을 전혀 보지 않은 상태에서 학습·추론을 수행해야 함.
목표	- 암호화된 BERT 임베딩만으로 로지스틱 회귀를 학습/추론하는 실용적 프라이버시 보호 텍스트 분류 시스템 구축. - Plaintext 성능에 근접한 유틸리티 + embedding inversion에 대한 강한 보호 확보.
방법론	1) 사용자 측(Local) - 문장 입력 → Sentence-BERT → 768-dim 임베딩 생성 → CKKS로 암호화 → 서버 전송. 2) 서버 측(Encrypted Learning) - 서버는 plaintext 임베딩을 절대 보지 않음. - 암호화된 임베딩 y~, 암호화된 파라미터 w~,b~만으로 로지스틱 회귀 학습·추론 수행. - CKKS로 ciphertext 덧셈/곱셈/부트스트래핑 지원. - sigmoid는 HE 연산을 위해 15차 다항식(minimax) 근사로 대체. - SGD 기반 weight update까지 ciphertext-only로 수행. 3) LDP baseline (Qu et al. 2021): - 임베딩 y에 노이즈 추가: y′=y+N - η로 noise 강도 조절 → 프라이버시–성능 trade-off 발생. 4) Efficient CKKS 구현 - level=3에서 암호화 → ciphertext 크기 약 7.4× 감소. - GPU 기반 bootstrapping → 충분한 multiplicative depth 확보.
학습에 사용된 데이터	Sentence-BERT 임베딩을 로컬에서 계산 후 암호화해 서버로 전달 1) Twitter Hate Speech - Train: 11,634 / Dev: 3,197 / Test: 4,795 2) SNIPS Intent Classification - Train: 13,084 / Dev: 700 / Test: 700 (7-class) - Multi-class는 OvR(One-vs-Rest)로 학습. 3) YouTube Spam Collection (YTSC) - Train: 1,564 / Dev: 196 / Test: 196 (PrivFT 비교용).
평가 메트릭	텍스트 분류 성능 - Binary: F1, AUC - Multi-class (SNIPS): macro F1, macro AUC Inversion 공격 평가 - 입력 문장 단어 복원 F1 (multi-label) 효율성 평가 - Ciphertext 크기 (GB) - 학습 시간 (sec/epoch) - GPU 사용량
결	1) 성능: Ciphertext ≈ Plaintext (~98.8–99%) - Twitter: Ciphertext F1 0.6596 (Plaintext 0.6625) - SNIPS: Ciphertext macro F1 0.9402 (Plaintext 0.9520) 2) LDP는 성능–프라이버시 trade-off가 심함 - LDP(η=175) Twitter F1=0.6404 (암호화 대비 ↓) - 강한 노이즈(η↓)일수록 inversion 보호 ↑, 그러나 성능 급락. 3) Inversion 공격 - Plaintext Sentence-BERT: F1=0.676 (복원 가능) - LDP(η=50): F1=0.190 (강한 보호) but 분류 성능 심각 저하. - HE(ciphertext): inversion 공격 자체 불가능 (plaintext를 전혀 보지 않으므로 모델 학습 불가). 4) PrivFT와 비교 (YTSC) - PrivFT: 8 GPUs, 60.48hr/epoch, Accuracy=0.863 - 본 논문: 1 GPU, 23.04sec/epoch, Accuracy=0.908 → 약 9,450× 빠르고, 더 높은 정확도.
주요 기여	1. Sentence-BERT 임베딩 + Homomorphic Encryption 조합을 통한 완전 암호화 텍스트 분류 최초의 실용적 구조. 2. 로지스틱 회귀 전체 학습을 ciphertext-only 로 구현 (forward/backward/SGD). 3. Plaintext와 거의 동등한 정확도 + 매우 강한 프라이버시 (inversion 불가능). 4. GPU 기반 CKKS + bootstrapping 최적화로 높은 효율성(기존 HE 기반 NN 학습 대비 압도적). 5. LDP/PrivFT 대비 장점 정량화: 정확도↑, 프라이버시↑, 학습비용↓.
한계	- 다운스트림 모델이 로지스틱 회귀로 제한, 복잡한 신경망(MLP/Transformer)은 HE 비용 과다. - Ciphertext 크기는 plaintext 대비 여전히 7~60× 증가 → 대규모 시스템 적용 시 통신비 부담. - HE 연산은 plaintext 연산 대비 여전히 느림 → 실시간 추론 시스템에는 제약. - Threat model이 서버 측 공격에 집중되어 있으며, 로컬 클라이언트 공격(키 도난, side-channel)은 범위 외. - 문장 수준 분류 외 다른 NLP 태스크(요약, 생성, QA)에는 적용 난이도가 증가.

이 논문은 BERT 계열 문장 임베딩을 동형암호(CKKS) 로 암호화한 상태에서 로지스틱 회귀 분류를 수행하여,
텍스트 분류 정확도는 거의 그대로 유지하면서도 임베딩 유출·역복원(embedding inversion) 위험을 없애는 방법을 제안합니다.

1. 문제 설정 (Problem Setting)

1.1 배경

BERT, ELMo, GPT 등 사전학습 언어모델의 임베딩은
- 다운스트림 태스크에서 높은 성능을 보이지만,
- 작성자 성별·나이 등의 민감 속성 유출 가능성이 있고,
- 경우에 따라 원문 토큰의 50–70%까지 복원 가능한 embedding inversion 공격이 보고됨.
특히 Sentence-BERT같은 문장 임베딩은 서비스 제공자에게 그대로 전달되는 경우가 많아,
- 서버가 임베딩을 수집하면,
- 별도의 공격 모델을 학습해 원문이나 민감 정보를 추정할 수 있음.

1.2 위협 모델 / 프라이버시 시나리오

Local privacy setting:
- 사용자가 로컬에서 Sentence-BERT로 문장 임베딩을 계산한 뒤,
- 그 임베딩에 프라이버시 메커니즘 (M_priv)을 적용한 후
  서버(서비스 제공자)로 넘긴다고 가정.
기존 방식:
- Local Differential Privacy(LDP) 기반: 임베딩에 노이즈를 더해 프라이버시를 확보.
- 하지만 노이즈 크기(η)에 따라 성능–프라이버시 트레이드오프가 심함.
목표:
1. 임베딩을 암호화하여 서버가 절대 평문 벡터를 볼 수 없게 만들고,
2. 그 상태에서 텍스트 분류 모델을 학습·추론하며,
3. plaintext classifier 수준에 근접한 성능을 유지하면서,
4. embedding inversion 같은 공격이 원천적으로 불가능하도록 만들기.

2. 방법론 (Method) – Step by Step

2.1 전체 파이프라인 개요

논문에서 정의하는 privatization 메커니즘은 다음과 같습니다.

[
M_{\text{priv}}(x) = P(F_{\text{emb}}(x))
]

(x): 원본 텍스트
(F_{\text{emb}}): Sentence-BERT 문장 임베딩 함수
(P): 프라이버시 메커니즘
- LDP baseline: 노이즈 (y + N)
- 제안 방법: 동형암호 (H(y))

Step-by-step (제안 방법)

로컬 임베딩 생성
- 사용자 단말에서 Sentence-BERT로 문장 (x)를 768차원 벡터 (y = F_{\text{emb}}(x))로 임베딩.
임베딩 암호화 (CKKS)
- 실수 벡터 (y \in \mathbb{R}^{768}) 를 CKKS 스킴으로 암호화:
  [
  \tilde{y} = H(y)
  ]
- CKKS는 근사 동형암호로, 실수/복소수 벡터에 대한 덧셈·곱셈을 암호 상태에서 지원.
암호화된 로지스틱 회귀 학습/추론
- 서버는 암호화된 임베딩 (\tilde{y}) 와 암호화된 파라미터를 이용해
  로지스틱 회귀를 암호 상태에서 학습/추론.
- 로지스틱 함수 (\sigma(x) = 1/(1+e^{-x}))는 다항식이 아니므로
  CKKS 상에서 직접 계산 불가 → 다항식 근사 사용.
  - ([-12, 12]) 구간에서 15차 minimax polynomial 근사,
  - 최대 근사 오차 ≈ 0.00614.
결과 복호화
- 서버는 암호화된 로짓/확률 결과를 사용자에게 전송.
- 사용자는 비밀키로 복호화해 최종 예측 결과(라벨)를 얻음.
훈련도 암호 상태에서 가능
- SGD 기반 로지스틱 회귀 학습을 암호화된 데이터/파라미터 위에서 수행.
- 부트스트래핑(bootstrapping)을 포함한 CKKS GPU 구현으로
  multiplicative depth 제약 없이 학습을 지원.

2.2 LDP Baseline (노이즈 기반 로컬 차등프라이버시)

Qu et al. (2021)을 따르는 baseline:

임베딩 (y \in \mathbb{R}^n) 에 대해,
[
P(y) = y + N
]
노이즈 (N)의 밀도:
[
p(N) \propto \exp(-\eta |N|)
]
샘플링 방법:
1. (r \sim \text{Gamma}(n, 1/\eta)) (반지름)
2. (p)를 단위 구 (B_n)에서 균일 샘플
3. (N = r p)
(\eta)가 작을수록 큰 노이즈 → 강한 프라이버시, 낮은 유틸리티.

2.3 CKKS 기반 HE 로지스틱 회귀 설계

CKKS 기본 연산

메시지 (m_1, m_2) 에 대한 복소 벡터를 담은 ciphertext (ct_1, ct_2) 에 대해:

Add(ct1, ct2) → (m_1 + m_2)
Mult(ct1, ct2) → (m_1 \odot m_2) (element-wise)
Bootstrap(ct1) → 동일 메시지 (m_1), 하지만 refreshed level (연산 가능 횟수 복원)

Level 설정 & 통신비 최적화

CKKS는 levelled HE:
- level (l): 남은 곱셈 가능한 depth.
- 두 ciphertext 곱셈 시 level은 (l-1)로 감소.
일반적으로는 최상위 level (L)에서 암호화하지만,
- 이 논문은 초기 level 3에서 암호화하여 ciphertext 크기를 줄임.
- 예:
  - Twitter train set: 10.8GB → 1.4GB (약 7.4× 감소)
  - SNIPS train set: 85.3GB → 11.4GB (약 7.4× 감소)

보안 수준 및 파라미터

CKKS 파라미터 예시:
- 폴리노미얼 차원 (N = 2^{17})
- 최대 모듈러스 크기 (q_L) = 1540 bits
- 보안 수준: 128-bit (LWE security estimator 기준)

GPU 구현

부트스트래핑 포함 CKKS 연산을 GPU (dual-NVLink Quadro RTX6000) 에 최적화.
결과적으로:
- 높은 multiplicative depth에서의 다항식 근사 가능
- 더 강한 보안 파라미터를 유지한 채 실용적인 연산 시간 확보

3. 실험 설정 (Experiments)

3.1 다운스트림 텍스트 분류 태스크

Tweets Hate Speech Detection
- 이진 분류: 혐오 발언(hate/racist/sexist) vs 기타
- 데이터 split:
  - Train: 11,634
  - Dev: 3,197
  - Test: 4,795
SNIPS Intent Classification
- 7개 사용자 의도(intent)를 분류하는 multi-class task
- Train/Dev/Test:
  - 13,084 / 700 / 700
- 평가 시 macro F1, macro AUC 사용
- Multi-class는 One-vs-Rest(OvR) 로 처리
YouTube Spam Collection (YTSC)
- UCI 리포지터리의 실 메시지 데이터셋
- 스팸 vs 정상 이진 분류
- Train/Dev/Test:
  - 1,564 / 196 / 196
- PrivFT(Badawi et al.)와 비교를 위해 사용

3.2 모델 및 학습 설정

임베딩:
- Sentence-BERT (768-dim 문장 임베딩)
Classifier:
- (Plaintext / Ciphertext / LDP 공통) 로지스틱 회귀
- Optimizer: SGD with Nesterov momentum
Hyperparameters (대략):
- Twitter:
  - Plaintext: lr=3.0, γ=0.9, batch=256, epoch=10
  - Ciphertext: lr=3.0, γ=0.9, batch=512, epoch=10
- SNIPS:
  - Plaintext: lr=3.0, γ=0.1, batch=128, epoch=10
  - Ciphertext: lr=2.0, γ=0.1, batch=512, epoch=10
LDP 노이즈:
- η ∈ {50, 75, 100, 125, 150, 175}
평가 메트릭:
- 텍스트 분류: F1, AUC
- Inversion: 단어 단위 F1 (multi-label)

4. 결과 (Results)

4.1 분류 성능: Ciphertext vs Plaintext vs LDP

Twitter Hate Speech (Binary)

Plaintext:
- Test F1 ≈ 0.6625
- Test AUC ≈ 0.9575
Ciphertext:
- Test F1 ≈ 0.6596 (plaintext의 약 98.9% 수준)
- Test AUC ≈ 0.9535
LDP (예: η=175) :
- Test F1 ≈ 0.6404
- Test AUC ≈ 0.9390
관찰:
- Ciphertext 모델은 거의 plaintext와 동급 성능.
- LDP는 η를 키워 노이즈를 줄여야 성능이 올라가지만,
  이때는 프라이버시 강도가 감소.

SNIPS Intent (7-class, OvR)

Plaintext:
- Test macro F1 ≈ 0.9520
- Test macro AUC ≈ 0.9959
Ciphertext:
- Test macro F1 ≈ 0.9402 (plaintext의 약 98.8%)
- Test macro AUC ≈ 0.9948
LDP (예: η=175):
- Test macro F1 ≈ 0.9345
- Test macro AUC ≈ 0.9900

→ HE 기반 ciphertext 분류기는 LDP보다 항상 높은/유사한 성능을 보이면서 plaintext와 거의 동일한 utility를 달성.

4.2 Embedding Inversion 결과

SNIPS에 대해 black-box sentence embedding inversion (Song & Raghunathan 스타일) 실행.

Plaintext Sentence-BERT 임베딩:
- Test F1 ≈ 0.6759 (입력 단어를 상당 부분 복원 가능)
LDP:
- η=50: Test F1 ≈ 0.1905
- η=175: Test F1 ≈ 0.4803
- 노이즈를 크게(η↓) 하면 inversion F1은 낮아지지만,
  앞선 분류 성능에서 보듯이 다운스트림 utility도 크게 감소.
Ciphertext:
- 서버는 평문 임베딩/결과에 접근할 수 없고,
- HE security 128-bit 수준에서 실질적으로 inversion 불가능.
- 따라서 black-box inversion 공격 자체가 정의 불가능한 수준.

4.3 PrivFT와의 비교 (YTSC)

PrivFT는 fastText+HE로 엔드투엔드 텍스트 분류를 수행하는 기존 방식. 본 논문은 “pretrained embedding + 간단한 HE classifier” 구조가 더 효율적이라고 주장.

결과 (YTSC):

모델 GPU 수 학습 시간 (per epoch) Test Accuracy

PrivFT	8	60.48 시간	0.863
Ciphertext (본 논문)	1	23.04 초	0.908
Plaintext	-	-	0.913

해석:
- 동일 데이터셋에서 정확도는 더 높고 (0.908 vs 0.863),
- 학습 속도는 약 9,450배 빠르며,
  GPU도 1장만 사용 (PrivFT는 8장).
- “사전학습 임베딩 + 암호화된 로지스틱 회귀” 구조가
  성능과 효율성 모두에서 우위를 보임.

4.4 통신·메모리 비용

CKKS level을 낮게 설정하여 (3) 초기 ciphertext 크기를 줄인 결과:
- Twitter train: 10.8GB → 1.4GB
- SNIPS train: 85.3GB → 11.4GB
다만 여전히 plaintext 대비 7~60배 크기:
- Twitter plaintext train: 183.7MB
- SNIPS plaintext train: 206.5MB
Training time:
- Ciphertext:
  - Twitter: 143.2 sec/epoch
  - SNIPS: 1111.4 sec/epoch
- LDP/Plaintext: 학습·추론 시간은 사실상 무시 가능한 수준 (저자 표현).

5. 기여 (Contributions)

논문의 핵심 기여를 연구자 관점에서 요약하면:

BERT 임베딩 + HE 로지스틱 회귀라는 단순하지만 강력한 구조 제안
- 사전학습 언어모델의 강력한 표현력을 활용하여,
  다운스트림 분류는 가벼운 암호화 모델로 처리.
CKKS 기반 GPU 구현 + 부트스트래핑 탑재
- 높은 보안 수준(128-bit)을 유지하면서도 충분한 multiplicative depth와 속도 확보.
LDP 대비 유틸리티/프라이버시 우수성 입증
- 동일한 문장 임베딩에서 LDP는 강한 프라이버시를 위해 성능을 희생해야 하지만,
- HE는 거의 zero-utility loss로 inversion risk를 제거.
PrivFT 대비 훈련 시간/정확도 개선
- HE 기반 텍스트 분류에서 “pretrained embedding 사용”이
  end-to-end HE NN 학습보다 압도적으로 실용적임을 실험적으로 보임.

6. 한계 및 향후 과제 (Limitations & Future Work)

논문에서 언급하거나 자연스럽게 도출되는 한계는 다음과 같습니다.

모델 복잡도 한계
- 현재 다운스트림 분류기는 로지스틱 회귀에 한정.
- 더 복잡한 신경망(MLP, transformer head 등)을 HE 위에서 돌리면
  연산량과 암호학적 비용이 급증.
통신·연산 비용
- ciphertext 크기가 plaintext 대비 여전히 최대 수십 배 크며,
- 분류기가 단순해도 HE 연산 자체는 여전히 무겁다.
- 대규모 온라인 서비스에 바로 적용하기에는 latency/throughput 이슈 존재.
Threat model 한정
- 사용자의 로컬 환경을 신뢰하고,
- 서버 측의 공격(embedding inversion, model inversion)에 초점을 둠.
- 로컬 단말 공격, 키 탈취, side-channel 등에 대해서는 다루지 않음.
태스크 범위
- 문장 수준 intent/hate-speech/spam 분류에 한정.
- 문서 수준 분류, sequence labeling, generation 등 다른 NLP 태스크에서는
  성능·비용 trade-off와 구현 난이도가 달라질 수 있음.

7. 한눈에 보는 논문 요약 표

나중에 논문을 다시 안 봐도 될 정도로, 핵심만 모은 요약 표입니다.

항목 내용

문제 상황	BERT/Sentence-BERT 임베딩이 민감 속성 유출 및 embedding inversion 공격에 취약. 사용자가 텍스트를 서비스에 보내지 않고도 분류 서비스를 받고 싶지만, 임베딩조차 서버에 평문으로 주기 어렵다.
목표	텍스트 분류 성능을 거의 유지하면서, 서버가 임베딩/결과를 평문으로 절대 볼 수 없도록 하는 privacy-preserving text classification 방법을 설계.
기본 아이디어	(1) 사용자가 로컬에서 Sentence-BERT 문장 임베딩을 계산, (2) 이를 CKKS 동형암호로 암호화, (3) 서버는 암호화된 임베딩 위에서 로지스틱 회귀를 학습/추론, (4) 예측 결과도 암호 상태로 사용자에게 전달 후 복호화.
프라이버시 메커니즘	LDP baseline: (P(y)= y+N), (p(N)\propto \exp(-\eta \|N\|)), η로 노이즈–성능 trade-off 조절. 제안 방법: (P(y)=H(y)), CKKS 동형암호로 임베딩 자체를 암호화.
암호 스킴 & 구현	CKKS (근사 HE), Add/Mult/Bootstrap 지원. 보안 수준 128-bit. level=3에서 암호화해 ciphertext 크기 감소. 부트스트래핑 포함 GPU 최적화로 고차 다항식 근사(로지스틱)와 효율적 학습/추론 지원.
다운스트림 모델	로지스틱 회귀 (binary 및 OvR multi-class). SGD+Nesterov, Sentence-BERT 768-dim 임베딩 입력.
데이터셋	(1) Tweets Hate Speech Detection (binary, 11,634/3,197/4,795) (2) SNIPS intent (7-class, 13,084/700/700) (3) YouTube Spam Collection (binary, 1,564/196/196; PrivFT와 비교용).
평가 메트릭	텍스트 분류: F1, AUC (SNIPS는 macro F1/macro AUC). Inversion: 입력 단어 복원 F1 (multi-label). 또한 ciphertext 크기, 학습시간, GPU 수 등 효율성 지표.
주요 결과 – 분류 성능	Ciphertext 로지스틱 회귀는 plaintext 대비 Twitter/SNIPS에서 F1/AUC의 약 98.8–99% 수준 유지. LDP는 η를 크게 해야 성능이 오르지만 이 경우 프라이버시 약화.
주요 결과 – Inversion	Plaintext Sentence-BERT 임베딩은 SNIPS에서 inversion F1≈0.676으로 상당한 복원 가능. LDP는 강한 노이즈에서 F1≈0.19까지 낮출 수 있으나, 이때 분류 성능도 크게 하락. HE는 서버가 평문에 접근하지 못하므로 black-box inversion 자체가 불가능하고, 128-bit 보안 수준을 제공.
PrivFT 비교	YTSC에서 PrivFT (8 GPU, 60.48hr/epoch, Acc=0.863) vs 본 논문 Ciphertext (1 GPU, 23.04s/epoch, Acc=0.908). → 약 9,450배 빠른 학습, 더 높은 정확도, GPU 자원 1/8 사용.
구현/효율	Level 3 암호화로 Twitter train ciphertext 1.4GB, SNIPS 11.4GB (plaintext 대비 약 7.4×). 학습 시간은 plaintext보다 크지만 HE 기반 텍스트 분류로서는 실용적인 수준.
기여	(1) BERT 임베딩 + HE 로지스틱 회귀라는 실용적 구조 제안 (2) 128-bit 보안 CKKS GPU 구현 및 부트스트래핑 포함 (3) LDP 대비 유틸리티–프라이버시 우위 실증 (4) PrivFT 대비 압도적인 시간/정확도 향상으로 “pretrained embedding + HE” 패러다임의 우수성 제시.
한계	분류기가 로지스틱 회귀에 제한, HE 연산·통신 비용 여전히 큼, threat model이 서버 측 공격에 집중, 태스크 범위가 문장 수준 분류에 한정.

이 정도면, 나중에 실험 설계할 때는

“Sentence-BERT 임베딩을 로컬에서 뽑고 HE로 암호화한 뒤, 서버는 암호 상태에서만 로지스틱 회귀를 학습/추론한다”
라는 핵심 구조와,
LDP/PrivFT 대비 성능·효율·프라이버시 비교 결과를 바로 떠올릴 수 있을 것입니다.

https://aclanthology.org/2023.emnlp-main.765/

Text Embeddings Reveal (Almost) As Much As Text

John Morris, Volodymyr Kuleshov, Vitaly Shmatikov, Alexander Rush. Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing. 2023.

aclanthology.org

Text Embeddings Reveal (Almost) As Much As Text

emnlp 메인이네요

텍스트 임베딩이 원본 텍스트를 복구할 수 있다!

32 token 입력의 92%를 복원해 냄

결국 embedding이 원본에 가까워질 때 까지 계속 생성한다는 거잖아
그럼 임베딩과 멀어졌다, 가까워졌다 판단은 어떻게 하고, 누가 어떻게 수정하라고 전달해??

아주 정확한 질문이야.
Vec2Text가 원본 임베딩에 가까워지도록 텍스트를 계속 수정(correction) 한다는 건 맞는데,
핵심은 다음 두 가지다:

✔ 1) “가까워졌다 / 멀어졌다”는 공격자가 직접 계산한다

공격자는 다음 정보를 가짐:

원본 임베딩 e (VectorDB에 저장된 값)
현재 생성한 텍스트 x(t)
embedding 모델에 대한 black-box query 권한 → ϕ(x(t))

그래서 공격자는:

cosine similarity(e, ϕ(x(t)))

를 직접 계산할 수 있다.

값이 1에 가까울수록 원본과 동일한 텍스트
값이 작아지면 멀어진 것

즉, 공격자가 cosine similarity를 compute하며 직접 모니터링한다.

✔ 2) “어떻게 수정하라고 전달하지?”

→ 수정 자체는 Vec2Text 모델(encoder-decoder)이 한다.

수정 명령을 언어적으로 주는 것이 아니다.
모델이 입력을 보고 스스로 텍스트를 수정한다.

Vec2Text의 correction 모델은 다음 입력을 받는다:

인코더 입력 구성

원본 임베딩 e
(MLP로 projection 후 sequence embedding 형태로 확장)
현재 예측 임베딩 ê(t) = ϕ(x(t))
임베딩 차이 (e − ê(t))
→ “어디가 부족한지”에 해당하는 gradient-free signal
현재 텍스트 x(t)의 token embeddings

이 네 가지 정보를 concat하여 인코더에 넣는다.

✔ 3) Correction 모델이 실제로 하는 일

Correction 모델은 “명령을 주면 고치는 게 아니라”,
입력된 임베딩 차이를 근거로, 다음 문장을 생성하는 모델이다.

즉:

입력: [원본 임베딩 정보, 현재 임베딩, 차이, 현재 문장]
출력: 수정된 새 문장 x(t+1)

이 과정에서 모델은 embedding space의 geometry를 학습해두었기 때문에,
차이가 e − ê(t)에 반응하여 문장을 수정한다.

✔ 4) 이걸 반복하면 뭐가 일어나나?

t=0: Base model이 대충 생성
공격자가 ϕ(x(0))을 embed
cos(e, ϕ(x(0))) 계산 → 0.85 같은 값
Correction model 입력:
- e
- ê(0)
- e−ê(0)
- x(0)

→ correction model이 x(1) 생성
→ 공격자가 다시 ϕ(x(1)) 계산
→ similarity가 올라갔는지 확인 (예: 0.92)

이걸 반복하면 결국 1.0 근처까지 수렴한다:

Example (논문 Table 4)

Round Cosine 예측

1	0.85	일부 날짜/장소 틀림
2	0.99	거의 정확
3	0.99	오타 일부
4	1.00	원문 완벽 복구

✔ 완전한 구조 흐름

embedding e  ← attacker has this

Base model → x(0)
ϕ(x(0)) → ê(0)
compute cos(e, ê(0)) → not good

Correction model inputs:
  [e, ê(0), e−ê(0), x(0)] → x(1)
ϕ(x(1)) → ê(1)
compute cos(e, ê(1)) → better

→ 반복

수정 “명령”은 인간이 내리지 않는다.
모델이 embedding difference를 보고 스스로 학습한 패턴으로 텍스트를 고친다.

✔ 요약

질문 답변

어떻게 가까워졌는지 확인?	공격자가 cosine similarity(e, ϕ(x)) 직접 계산
누가 수정하라고 알려줘?	아무도 언어로 알려주지 않음. Correction 모델이 e−ê(t)를 기반으로 수정
어떤 신호로 수정?	embedding 차이 (e−ê(t))를 MLP projection하여 encoder에 입력
수정 반복 구조는?	모델이 자동 생성 → embed → 비교 → 다시 생성

필요하면 이 correction 모델의 입력 구조를
수식 + 그림 수준으로 더 정교하게 설명해줄게.

그럼 계속해서 concat해서 늘어나니까 입력이 엄청 길어지겠네???

결론부터 말하면 입력이 계속 길어지지 않는다.
왜냐하면 Vec2Text는 “이전 모든 단계의 히스토리를 누적하는 방식이 아니라”
매 correction step마다 고정된 구조의 입력만 넣기 때문이다.

즉, concat되는 길이는 매 step 동일하게 유지된다.

✔ 왜 입력이 늘어나지 않을까?

Vec2Text correction 모델은 t번째 단계에서 다음을 입력으로 받는다:

EmbToSeq(e) — 원본 임베딩
EmbToSeq(ê(t)) — 현재 예측 임베딩
EmbToSeq(e − ê(t)) — 둘의 차이
WordEmbedding(x(t)) — 현재 텍스트의 토큰들

이 네 개만 매번 사용한다.

✔ t=1이든 t=50이든 구성은 항상 동일하다

즉:

concat( [16개 projection], [16개 projection], [16개 projection], [현재 문장 길이 n] )

만 들어가며, t가 증가하더라도 “새로 생성된 x(t) 전체를 누적 저장”하지 않는다.

✔ 구체적으로 입력 길이가 고정되는 이유

논문의 Section 3.2에 명시되어 있음:

각 embedding(e, ê(t), e−ê(t))은
MLP → σ → MLP → reshape → ‘길이 s’의 시퀀스로 변환됨

s = 16 (논문 기본값)
embedding dimension d = varies (e.g., 768)

따라서 1개의 embedding → 길이 16의 pseudo-sequence

Correction 모델 입력 길이는 다음:

= 16 (e)
+ 16 (ê(t))
+ 16 (e−ê(t))
+ n (x(t)의 token 수)

총 길이 = 48 + n

✔ “t가 증가할수록 concat 증가?” → X

t 증가 시 달라지는 건 **ê(t)**와 x(t) 뿐이다.

하지만 모델은 이전 step의 입력을 memory처럼 쌓지 않고,
매 step마다 새로운 고정된 형태의 input sequence를 하나 생성할 뿐.

즉:

t=0 → concat(e, ê(0), diff(0), x(0))
t=1 → concat(e, ê(1), diff(1), x(1))
t=2 → concat(e, ê(2), diff(2), x(2))

이렇게 “새로운 입력을 한 번씩” 넣고 결과를 생성한다.

✔ 결론: 입력은 절대 누적되지 않는다

Step 입력 길이 설명

t=0	48 + n	base 초기화
t=1	48 + n	수정된 텍스트 길이에 따라 n만 변함
t=50	48 + n	여전히 동일한 형태

입력은 매번 재구성되며, 히스토리를 누적하지 않는다.
따라서 입력이 기하급수적으로 늘어나는 문제는 없다.

좋은 지적이야.
겉으로 보면 **“이전 step의 히스토리를 입력에 누적하지 않는데 어떻게 개선(수렴)해 나가는가?”**라는 의문이 당연히 생긴다.
하지만 Vec2Text는 히스토리를 저장할 필요가 없는 구조로 설계되어 있다.
오히려 “히스토리를 따로 저장하지 않기 때문에” 더 잘 수렴한다.

아래에서 왜 그런지 기계학습적·최적화적 관점에서 명확하게 설명할게.

✔ 핵심 요약

Vec2Text에서 *“과거 step의 정보”*는 텍스트 형태로 기억하는 것이 아니라,
현재 embedding ê(t)와 원본 embedding e의 차이 (e − ê(t)) 안에 이미 *모든 필요한 정보가 응축되어 있기 때문**이다.

따라서 과거 텍스트가 없어도 “지금 어느 방향으로 수정해야 하는지”를 100% 알 수 있다.

✔ 왜 히스토리가 없어도 되는가?

✨ 1) “임베딩 차이(e − ê(t))”가 사실상 최적화 방향(gradient) 역할을 한다

Vec2Text는 gradient를 사용할 수 없는 상황(black-box encoder)에서
유일하게 가능한 방향 신호 → e − ê(t) 를 사용한다.

이 차이는 다음을 나타냄:

문장이 “어떤 semantic dimension”에서 부족한지
얼마나 더 원본 방향으로 이동해야 하는지
어떤 구성 요소가 잘못되었는지

즉, correction 모델은 "문장 전체의 하이레벨 수정 방향"을 embedding difference에서 얻는다.

과거 문장은 필요 없음.
지금 모델이 어디에 서 있는지만 알면 어디로 가야 할지 알 수 있다.

✨ 2) 이전 텍스트 전체를 기억하는 것이 오히려 비효율적이다

예를 들어 t=10에서의 문장은 이미 크게 수정된 상태이므로
t=0~t=9의 문장을 모두 기억하는 것은 불필요한 노이즈가 됨.

최적화 관점에서는 다음만 필요하다:

현재 위치(ê(t))
목표 위치(e)
방향(e − ê(t))

즉, 과거 경로는 필요 없다.
최적화 문제에서 gradient descent가 과거 step을 기억하지 않는 것과 동일한 원리.

✨ 3) x(t) 자체에는 과거 수정 내용이 “이미 내재”되어 있다

모델 입력에는 항상 현재 텍스트 x(t) 자체가 포함된다.

concat(
    EmbToSeq(e),
    EmbToSeq(ê(t)),
    EmbToSeq(e − ê(t)),
    WordEmbedding(x(t))
)

여기서 x(t)는 다음을 포함:

지금까지 모든 수정 결과
현재 문장이 가진 syntax/lexical 구조
이미 정제된 부분, 수정이 필요한 부분

즉, 과거에 어떤 수정이 있었는지는 x(t) 텍스트 자체가 충분히 표현하고 있다.

그러니 과거 step의 텍스트를 따로 넣을 필요가 없다.

✨ 4) 정교한 self-correcting 능력은 모델이 학습한다

Correction 모델은 다음 작업을 학습한다:

embedding 차이를 보고 “무엇이 틀렸는지” 판단
현재 텍스트를 읽고 “어떻게 고칠지” 결정
출력으로 x(t+1) 생성

이 모델은 training 과정에서 수천만 쌍의
(x(t), ê(t)) → x(t+1) 패턴을 학습한다.

그래서 과거 히스토리를 직접 보지 않아도:

지금 문장을 어떻게 고쳐야 더 가까워지는지
어떤 오타/지명/날짜/구조가 잘못되었는지
어떤 token을 교체해야 하는지

이걸 embedding 공간 위에서 학습된 분포로 정정한다.

✨ 5) 최종적으로는 “embedding fixed-point iteration”이다

Vec2Text는 수학적으로는 다음과 동일하다:

x(t+1) = f( x(t), e )

이 반복은 embedding 공간에서 fixed point iteration 형태로 수렴한다.

즉:

ê(t) → e 로 수렴
x(t) → x* (원본 문장)로 수렴

수렴에 필요한 정보는 오직:

현재 값 ê(t)
목표 값 e
양자의 차이

뿐이다.

✔ 정리: 왜 히스토리 없는데도 잘 작동하는가?

요소 역할

x(t)	지금까지의 모든 수정 결과를 포함
ê(t)	현재 상태의 embedding
e − ê(t)	“어디가 얼마나 틀렸는지”를 나타내는 gradient-like 신호
correction model	위 세 정보를 기반으로 다음 문장을 학습적으로 생성

즉:

현재 상태 + 현재 오류 신호만 있으면 다음 step 수정은 충분하다.
과거 history는 필요 없다.

🔧 원하면 더 깊게 설명해줄 수 있어

“embedding difference가 gradient처럼 동작하는 이유”
“왜 이 구조가 non-differentiable black-box에서도 작동하는가”
“왜 correction 모델이 학습만으로 semantic editing을 할 수 있는가”
“LLM fine-tuning 시 self-correction이 어떻게 일반화되는가”

등도 더 자세히 설명 가능해.

계속 궁금한 점 말해줘!

문제 상황	- Vector DB/RAG 시스템에서 사용자 텍스트 대신 임베딩만 저장해도 안전하다고 여김 - 그러나 이 임베딩이 실제로는 원본 텍스트를 거의 완벽히 복원할 만큼 정보가 풍부한지 검증된 적 없음 - 공격자가 embedding 모델(black-box)만 갖고도, 임베딩을 통해 원문을 유추할 수 있다면 중대한 프라이버시 침해 발생
연구 질문	“임베딩만으로 원본 텍스트를 어느 수준까지 복원할 수 있는가?” “Sentence embedding은 정말 비식별화된 데이터인가?”
학습 데이터	GTR-base 모델 학습: 　- Wikipedia(Natural Questions) 문서 5M개 (각 32 tokens) OpenAI ada-002 모델 학습: 　- MS MARCO (32-token 버전 / 128-token 버전)
평가 데이터	- In-domain: Natural Questions, MS MARCO - Out-of-domain: BEIR 15개 데이터셋 (Quora, DBPedia, FiQA, HotpotQA, etc.) - 특수 도메인: MIMIC-III (의료 임상노트; pseudo-reidentified names)
평가 지표	- BLEU: n-gram 정확도 - Token F1: token-level recall/precision - Exact Match: 완전 동일 문자열 비율 - Cosine similarity: 임베딩 복구 성능
주요 실험 결과	🔹 In-domain 결과 (GTR-base 32 tokens) - Base model: BLEU 31.9, EM 0% - Vec2Text (50 steps + s-beam): BLEU 97.3, Exact Match 92%, cosine 0.99 🔹 OpenAI Ada-002 (32 tokens) - Exact Match 60.9%, BLEU 83.4 🔹 Out-of-domain (BEIR 15 datasets) - 문서 길이가 길어질수록 성능 감소 - Quora에서 BLEU 95.5 - 대부분 Token F1 40–90 수준 🔹 MIMIC-III 의료 데이터 - first name: 94.2% 복구 - last name: 95.3% 복구 - full name: 89.2% 복구 → 심각한 프라이버시 위험 실증
추가 분석	- embedding similarity와 BLEU는 강한 양의 상관관계 (cos=1 근처면 거의 무조건 정확 복구) - feedback(ê(t) 사용)이 없으면 성능 급락 - 초기값이 무작위여도 iterative correction만으로 원문에 수렴
방어 실험	- embedding에 Gaussian noise 추가 시 효과적 - λ=0.01 → retrieval 성능 2% 감소, reconstruction BLEU는 80 → 10 수준으로 붕괴 - noise가 완벽한 방어는 아님 (adaptive training 시 극복 가능성 있음)
기여	✓ 최초로 state-of-the-art embedding에서 full ordered text reconstruction 성공 ✓ iterative correction라는 새로운 inversion 패러다임 제안 ✓ 의료 데이터에서의 이름 복구로 embedding의 프라이버시 위험을 명확히 입증 ✓ embedding은 “부분 정보”가 아니라 사실상 raw text와 동등한 민감 데이터임을 증명
한계	- 128 tokens 이상 복원은 아직 어려움 - black-box embedding 모델에 매 step query 필요 → 비용·latency 큼 - noise defense에 대해 adaptive 공격 연구 부족 - beam search 더 키우면 성능 더 증가할 가능성 있으나 비용 증가 - 긴 문서 수천 토큰 단위 inversion은 미해결
핵심 결론	*“Dense text embeddings are not anonymized. They leak as much private information as raw text.” → 임베딩은 반드시 raw text 수준으로 보호해야 하며, RAG/VectorDB 시스템 설계 시 보안 재고가 필요함

저작자표시 비영리 (새창열림)

'인공지능 > 논문 리뷰 or 진행' 카테고리의 다른 글

Prompting Large Language Models with Speech Recognition Abilities - Code 구현 (0)	2025.12.03
Privacy AI 관련 조사 3 (0)	2025.12.03
Privacy AI 관련 조사 1 (0)	2025.12.02
ACL 2025 - Pretraining Context Compressor for Large Language Models with Embedding-Based Memory (0)	2025.12.01
Soft Thinking: Unlocking the Reasoning Potential of LLMs in Continuous Concept Space (0)	2025.12.01

현재글Privacy AI 관련 조사 2

NLP, AI, XAI에 관심있는 공대생의 일기장...?

Today :
Yesterday :

« 2026/02 »
일	월	화	수	목	금	토
1	2	3	4	5	6	7
8	9	10	11	12	13	14
15	16	17	18	19	20	21
22	23	24	25	26	27	28