sorryhyun/sentence-embedding-klue-large

Uso (API de inferencia Huggingface)

import requests

API_URL = "https://api-inference.huggingface.co/models/sorryhyun/sentence-embedding-klue-large"
headers = {"Authorization": "your_HF_token"}

def query(payload):
    response = requests.post(API_URL, headers=headers, json=payload)
    return response.json()

output = query({
    "inputs": {
        "source_sentence": "좋아요, 추천, 알림설정까지",
        "sentences": [
            "좋아요 눌러주세요!!",
            "좋아요, 추천 등 유투버들이 좋아해요",
            "알림설정을 눌러주시면 감사드리겠습니다."
        ]
    },
})
if __name__ == '__main__':
    print(output)

Uso (Transformers de HuggingFace)

from transformers import AutoTokenizer, AutoModel, DataCollatorWithPadding
import torch
from torch.utils.data import DataLoader

device = torch.device('cuda')

# Oraciones para las que queremos obtener incrustaciones
sentences = ['This is an example sentence', 'Each sentence is converted']

# Cargar modelo del Hub de HuggingFace
modelo_nombre = 'sorryhyun/sentence-embedding-klue-large'
tokenizer = AutoTokenizer.from_pretrained(modelo_nombre)
collator = DataCollatorWithPadding(tokenizer)
model = AutoModel.from_pretrained(modelo_nombre).to(device)

tokenized_data = tokenizer(sentences, padding=True, truncation=True)
tokenized_data = tokenized_data.remove_columns('text')
dataloader = DataLoader(tokenized_data, batch_size=32, pin_memory=True, collate_fn=collator)
all_outputs = torch.zeros((len(tokenized_data), 1024)).to(device)
start_idx = 0

# Método de pooling promedio para representación de oraciones
with torch.no_grad():
    for inputs in dataloader:
        inputs = {k: v.to(device) for k, v in inputs.items()}
        representations, _ = model(**inputs, return_dict=False)
        attention_mask = inputs["attention_mask"]
        input_mask_expanded = attention_mask.unsqueeze(-1).expand(representations.size()).to(representations.dtype)
        summed = torch.sum(representations * input_mask_expanded, 1)
        sum_mask = input_mask_expanded.sum(1)
        sum_mask = torch.clamp(sum_mask, min=1e-9)
        end_idx = start_idx + representations.shape[0]
        all_outputs[start_idx:end_idx] = summed / sum_mask
        start_idx = end_idx