ko-sroberta-sts

Uso (Sentence-Transformers)

Usar este modelo es fácil cuando tienes sentence-transformers instalado:

pip install -U sentence-transformers

Luego puedes usar el modelo de la siguiente manera:

from sentence_transformers import SentenceTransformer
sentences = ["안녕하세요?", "한국어 문장 임베딩을 위한 버트 모델입니다."]

model = SentenceTransformer('jhgan/ko-sroberta-sts')
embeddings = model.encode(sentences)
print(embeddings)

Uso (HuggingFace Transformers)

Sin sentence-transformers, puedes usar el modelo de la siguiente manera: Primero, pasas tu entrada a través del modelo transformer, luego debes aplicar la operación de pooling correcta sobre las incrustaciones de palabras contextualizadas.

from transformers import AutoTokenizer, AutoModel
import torch

# Mean Pooling - Take attention mask into account for correct averaging
def mean_pooling(model_output, attention_mask):
    token_embeddings = model_output[0] # Primer elemento de model_output contiene todas las incrustaciones de tokens
    input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
    return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)

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

# Cargar modelo desde HuggingFace Hub	tokenizer = AutoTokenizer.from_pretrained('jhgan/ko-sroberta-sts')	
modelo = AutoModel.from_pretrained('jhgan/ko-sroberta-sts')

# Tokenizar oraciones	encoded_input = tokenizer(sentences, padding=True, truncation=True, return_tensors='pt')

# Calcular incrustaciones de tokens	with torch.no_grad():
    model_output = model(**encoded_input)

# Realizar pooling.	En este caso, pooling promedio.	sentence_embeddings = mean_pooling(model_output, encoded_input['attention_mask'])

print("Incrustaciones de oraciones:")
print(sentence_embeddings)

Resultados de Evaluación

KorSTS 학습 데이터셋으로 학습한 후 KorSTS 평가 데이터셋으로 평가한 결과입니다.

Cosine Pearson: 81.84
Cosine Spearman: 81.82
Euclidean Pearson: 81.15
Euclidean Spearman: 81.25
Manhattan Pearson: 81.14
Manhattan Spearman: 81.25
Dot Pearson: 79.09
Dot Spearman: 78.54

Entrenamiento

El modelo fue entrenado con los parámetros:

DataLoader:
torch.utils.data.dataloader.DataLoader de longitud 719 con los parámetros:
{'batch_size': 8, 'sampler': 'torch.utils.data.sampler.RandomSampler', 'batch_sampler': 'torch.utils.data.sampler.BatchSampler'}

Loss:
sentence_transformers.losses.CosineSimilarityLoss.CosineSimilarityLoss
Parámetros del Método fit():
{
"epochs": 5,
"evaluation_steps": 1000,
"evaluator": "sentence_transformers.evaluation.EmbeddingSimilarityEvaluator.EmbeddingSimilarityEvaluator",
"max_grad_norm": 1,
"optimizer_class": "",
"optimizer_params": {
"lr": 2e-05
},
"scheduler": "WarmupLinear",
"steps_per_epoch": null,
"warmup_steps": 360,
"weight_decay": 0.01
}

Arquitectura completa del modelo

SentenceTransformer(
    (0): Transformer({'max_seq_length': 128, 'do_lower_case': False}) con modelo Transformer: RobertaModel
    (1): Pooling({'word_embedding_dimension': 768, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False})
)