---
license: apache-2.0
pipeline_tag: sentence-similarity
tags:
  - sentence-transformers
  - feature-extraction
  - sentence-similarity
  - transformers
library_name: generic
language:
- vi
---

# thehosy/roberta-base-qa-vietnamese

This is a encoder model: It can encodes sentences or paragraphs (maximum 768 tokens) to dense vectors with 768 dimensions. It used for QA semantic search.

Datasets: 
  - MS Macro (translated into Vietnamese)
  - SQuAD v2  (translated into Vietnamese)
  - ViQuad2.0
  - ZaloQA 2019

Roberta-base architecture is used as backbone (Training from scratch).

<!--- Describe your model here -->

## Usage (Sentence-Transformers)

Using this model becomes easy when you have [sentence-transformers](https://www.SBERT.net) installed:

```
pip install -q sentence-transformers
```

Then you can use the model like this:

```python
from sentence_transformers import SentenceTransformer
from torch.nn import functional as F


sentences = ["Mỗi hiệp bóng đá kéo dài bao lâu",
  "Một trận đấu bóng đá thông thường có hai hiệp , mỗi hiệp 45 phút với khoảng thời gian 15 phút nghỉ giữa hai hiệp .",
  "Cũng trong thập niên 1850 , các đội bóng nghiệp dư bắt đầu được thành lập và thường mỗi đội xây dựng cho riêng họ những luật chơi mới của môn bóng đá , trong đó đáng chú ý có câu lạc bộ Sheffield F.C .. Việc mỗi đội bóng có luật chơi khác nhau khiến việc điều hành mỗi trận đấu giữa họ diễn ra rất khó khăn ."]

model = SentenceTransformer('thehosy/roberta-base-qa-vietnamese')
model.eval()

embeddings = model.encode(sentences, convert_to_tensor=True)
vecs = F.normalize(embeddings)
sim_scores = F.cosine_similarity(vecs[:1], vecs[1:])
print(sim_scores)

# tensor([0.9971, 0.3511])
```

## Usage (HuggingFace Transformers)

You can alse use the model with transformers by applying the pooling (mean pooling) on-top of the contextualized word embeddings.

```python
from transformers import AutoTokenizer, AutoModel
import torch
from torch.nn import functional as F


#Mean Pooling - Take attention mask into account for correct averaging
def mean_pooling(model_output, attention_mask):
    token_embeddings = model_output.last_hidden_state
    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)


sentences = ["Mỗi hiệp bóng đá kéo dài bao lâu",
  "Một trận đấu bóng đá thông thường có hai hiệp , mỗi hiệp 45 phút với khoảng thời gian 15 phút nghỉ giữa hai hiệp .",
  "Cũng trong thập niên 1850 , các đội bóng nghiệp dư bắt đầu được thành lập và thường mỗi đội xây dựng cho riêng họ những luật chơi mới của môn bóng đá , trong đó đáng chú ý có câu lạc bộ Sheffield F.C .. Việc mỗi đội bóng có luật chơi khác nhau khiến việc điều hành mỗi trận đấu giữa họ diễn ra rất khó khăn ."]

# Load model from HuggingFace Hub
tokenizer = AutoTokenizer.from_pretrained('thehosy/roberta-base-qa-vietnamese')
model = AutoModel.from_pretrained('thehosy/roberta-base-qa-vietnamese')
model.eval()

# Tokenize sentences
encoded_input = tokenizer(sentences, padding=True, truncation=True, return_tensors='pt')
# Compute token embeddings
with torch.no_grad():
    model_output = model(**encoded_input)

embeddings = mean_pooling(model_output, encoded_input['attention_mask'])
vecs = F.normalize(embeddings)
sim_scores = F.cosine_similarity(vecs[:1], vecs[1:])
print(sim_scores)

# tensor([0.9971, 0.3511])
```

## Training

The model was trained with the parameters:

**DataLoader**:

`torch.utils.data.dataloader.DataLoader` of length 683064 with parameters:

```json
{'batch_size': 16, 'sampler': None, 'batch_sampler': None, 'shuffle': true}
```

**Loss**:

`contrastive loss` with `cosine distance` and `euclide distance`:

**Training Parameters**
 - epochs: 6
 - optimizer: AdamW
 - learning_rate: 2e-05
 - scheduler: Warmup Linear Scheduler
 - warmup_steps: 10000
 - weight_decay": 0.001


## Full Model Architecture

```
SentenceTransformer(
  (0): Transformer({'max_seq_length': 768, 'do_lower_case': False}) with Transformer model: 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, 'pooling_mode_weightedmean_tokens': False, 'pooling_mode_lasttoken': False})
)
```