嵌入反演攻擊

# 步驟 1：產生訓練資料
training_pairs = []
for text in corpus:
    embedding = target_model.encode(text)
    training_pairs.append((embedding, text))
 
# 步驟 2：訓練反演模型
# 架構：嵌入向量 → 解碼器 → 文字 token
class InversionModel(nn.Module):
    def __init__(self, embedding_dim, vocab_size, hidden_dim=512):
        super().__init__()
        self.projection = nn.Linear(embedding_dim, hidden_dim)
        self.decoder = nn.TransformerDecoder(
            nn.TransformerDecoderLayer(d_model=hidden_dim, nhead=8),
            num_layers=6
        )
        self.output = nn.Linear(hidden_dim, vocab_size)
 
    def forward(self, embedding, target_tokens):
        # 將嵌入投影至解碼器的隱藏空間
        memory = self.projection(embedding).unsqueeze(0)
        # 解碼出文字 token
        output = self.decoder(target_tokens, memory)
        return self.output(output)

# 對 OpenAI 嵌入的反演思路
# 攻擊者無法存取模型權重，因此需使用已訓練之反演模型
 
# 以領域吻合語料產生訓練資料
import openai
 
def generate_training_data(texts):
    pairs = []
    for text in texts:
        response = openai.embeddings.create(
            model="text-embedding-3-small",
            input=text
        )
        embedding = response.data[0].embedding
        pairs.append((embedding, text))
    return pairs
 
# 於這些配對上訓練反演模型
# 再對自向量資料庫擷取到的目標嵌入套用

# 有模型存取權時，攻擊者除了訓練式反演，
# 還可使用梯度式反演
 
def gradient_inversion(model, target_embedding, num_steps=1000):
    # 以隨機 token 嵌入初始化
    input_embeds = torch.randn(1, max_len, model.config.hidden_size,
                                requires_grad=True)
 
    optimizer = torch.optim.Adam([input_embeds], lr=0.01)
 
    for step in range(num_steps):
        optimizer.zero_grad()
        output = model(inputs_embeds=input_embeds)
        current_embedding = output.last_hidden_state.mean(dim=1)
 
        # 最小化與目標嵌入的距離
        loss = 1 - torch.nn.functional.cosine_similarity(
            current_embedding, target_embedding
        )
        loss.backward()
        optimizer.step()
 
    # 將最佳化後的嵌入映射回最接近的 token
    return find_nearest_tokens(model, input_embeds)