| Training Loss | Epoch | Step  | Validation Loss | Rouge1 | Rouge2 | Rougel | Rougelsum | Gen Len |
|:-------------:|:-----:|:-----:|:---------------:|:------:|:------:|:------:|:---------:|:-------:|
| 1.5931        | 0.2   | 1000  | 1.3196          | 4.4689 | 2.1047 | 3.7843 | 4.1547    | 19.0    |
| 1.027         | 0.41  | 2000  | 1.0844          | 5.1347 | 3.1235 | 4.5451 | 4.8552    | 19.0    |
| 0.9049        | 0.61  | 3000  | 1.0237          | 5.3317 | 3.3471 | 4.7794 | 5.0768    | 18.9424 |
| 0.882         | 0.81  | 4000  | 0.9865          | 5.2587 | 3.3334 | 4.7093 | 5.0145    | 18.9616 |
| 0.8066        | 1.01  | 5000  | 0.9767          | 5.32   | 3.4174 | 4.7539 | 5.0575    | 18.972  |
| 0.7554        | 1.22  | 6000  | 0.9600          | 5.3752 | 3.4463 | 4.8187 | 5.1241    | 18.7912 |
| 0.7834        | 1.42  | 7000  | 0.9542          | 5.2947 | 3.4524 | 4.7691 | 5.0477    | 18.7944 |
| 0.7562        | 1.62  | 8000  | 0.9472          | 5.3469 | 3.4304 | 4.8054 | 5.0803    | 18.9712 |
| 0.6888        | 1.83  | 9000  | 0.9386          | 5.3514 | 3.4856 | 4.8369 | 5.099     | 18.9736 |
| 0.7547        | 2.03  | 10000 | 0.9339          | 5.2872 | 3.4267 | 4.7643 | 5.0413    | 18.9016 |
| 0.6819        | 2.23  | 11000 | 0.9324          | 5.3548 | 3.4816 | 4.833  | 5.1086    | 18.9016 |
| 0.7078        | 2.43  | 12000 | 0.9283          | 5.3617 | 3.4891 | 4.8427 | 5.1142    | 18.9352 |
| 0.7102        | 2.64  | 13000 | 0.9226          | 5.3569 | 3.5107 | 4.8517 | 5.121     | 18.8584 |
| 0.686         | 2.84  | 14000 | 0.9209          | 5.353  | 3.5113 | 4.8279 | 5.0875    | 18.8792 |
| 0.6995        | 3.04  | 15000 | 0.9194          | 5.3582 | 3.4907 | 4.8356 | 5.096     | 18.9064 |
| 0.6972        | 3.24  | 16000 | 0.9186          | 5.413  | 3.5532 | 4.8931 | 5.1588    | 18.9808 |
| 0.6894        | 3.45  | 17000 | 0.9185          | 5.4234 | 3.5807 | 4.9136 | 5.1733    | 18.9448 |
| 0.6327        | 3.65  | 18000 | 0.9171          | 5.3869 | 3.4862 | 4.8449 | 5.1144    | 18.9304 |
| 0.6324        | 3.85  | 19000 | 0.9175          | 5.4194 | 3.5546 | 4.8938 | 5.1583    | 18.94   |


### Framework versions


- Transformers 4.16.0.dev0
- Pytorch 1.7.0
- Datasets 1.17.0
- Tokenizers 0.11.0


model name: finetuned-T5


model author: nadzma


task: text2text-generation


tags: pytorch, t5, text2text-generation, transformers, license:apache-2.0, generated_from_trainer, model-index, autonlp_compatible


tags:


- generated_from_trainer
metrics:
- rouge
model-index:
- name: finetuned-Pegasus-UK-financial-summarization
results: []


<!-- This model card has been generated automatically according to the information the Trainer had access to. You
should probably proofread and complete it, then remove this comment. -->


# finetuned-Pegasus-UK-financial-summarization


This model is a fine-tuned version of [google/pegasus-large](https://huggingface.co/google/pegasus-large) on an unknown dataset.
It achieves the following results on the evaluation set:


- Loss: 1.2250
- Rouge1: 44.119
- Rouge2: 29.6139
- Rougel: 33.9525
- Rougelsum: 39.9444
- Gen Len: 251.2314


## Model description


More information needed


## Intended uses & limitations


## Training and evaluation data


## Training procedure


### Training hyperparameters


The following hyperparameters were used during training:


- learning_rate: 5e-05
- train_batch_size: 2
- eval_batch_size: 2
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- lr_scheduler_warmup_ratio: 0.1
- num_epochs: 4.0


### Training results


| Training Loss | Epoch | Step | Validation Loss | Rouge1  | Rouge2  | Rougel  | Rougelsum | Gen Len  |
|:-------------:|:-----:|:----:|:---------------:|:-------:|:-------:|:-------:|:---------:|:--------:|
| 1.9242        | 0.67  | 1000 | 1.6052          | 38.1342 | 23.4131 | 28.158  | 33.6354   | 239.8072 |
| 1.6655        | 1.34  | 2000 | 1.3772          | 40.4674 | 25.4758 | 30.0461 | 35.9142   | 246.4132 |
| 1.6143        | 2.01  | 3000 | 1.2855          | 42.1033 | 27.621  | 32.1946 | 38.1069   | 244.8567 |
| 1.4952        | 2.68  | 4000 | 1.2543          | 42.7074 | 28.1285 | 32.7136 | 38.7029   | 249.4408 |
| 1.4283        | 3.34  | 5000 | 1.2312          | 42.9139 | 28.2964 | 32.849  | 38.8668   | 251.2645 |


### Framework versions


model name: finetuned-Pegasus-UK-financial-summarization


model author: nadzma


task: text2text-generation


tags: pytorch, pegasus, text2text-generation, transformers, generated_from_trainer, model-index, autonlp_compatible


license: apache-2.0
tags:


- generated_from_trainer
metrics:
- rouge
model-index:
- name: finetuned-BART-UK-financial-summarization-multiple-references
results: []


# finetuned-BART-UK-financial-summarization-multiple-references


This model is a fine-tuned version of [facebook/bart-base](https://huggingface.co/facebook/bart-base) on an unknown dataset.
It achieves the following results on the evaluation set:


- Loss: 1.8651
- Rouge1: 30.2768
- Rouge2: 16.5597
- Rougel: 23.9264
- Rougelsum: 29.9211
- Gen Len: 114.7128


## Model description


More information needed


## Intended uses & limitations


## Training and evaluation data


## Training procedure


### Training hyperparameters


- learning_rate: 5e-05
- train_batch_size: 1
- eval_batch_size: 4
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- lr_scheduler_warmup_ratio: 0.1
- num_epochs: 4.0


### Training results


| Training Loss | Epoch | Step  | Validation Loss | Rouge1  | Rouge2 | Rougel  | Rougelsum | Gen Len |
|:-------------:|:-----:|:-----:|:---------------:|:-------:|:------:|:-------:|:---------:|:-------:|
| 3.0082        | 0.1   | 1000  | 2.4917          | 13.4643 | 8.5691 | 12.4617 | 13.3171   | 20.0    |
| 2.4695        | 0.2   | 2000  | 2.3554          | 12.3599 | 8.0996 | 11.4208 | 12.2321   | 20.0    |
| 2.2945        | 0.3   | 3000  | 2.2914          | 12.6496 | 8.3592 | 11.7265 | 12.5178   | 19.8696 |
| 2.4193        | 0.41  | 4000  | 2.2373          | 13.1184 | 8.7248 | 12.2447 | 13.019    | 20.0    |
| 2.2386        | 0.51  | 5000  | 2.2263          | 11.7267 | 7.5929 | 10.8553 | 11.5917   | 18.264  |
| 2.2384        | 0.61  | 6000  | 2.2009          | 13.6181 | 9.1253 | 12.6438 | 13.4864   | 20.0    |
| 2.1491        | 0.71  | 7000  | 2.1802          | 12.7595 | 8.2607 | 11.8995 | 12.6552   | 20.0    |
| 2.1001        | 0.81  | 8000  | 2.1458          | 12.6461 | 8.2799 | 11.7226 | 12.5094   | 19.9408 |
| 2.0731        | 0.91  | 9000  | 2.0940          | 13.098  | 8.5378 | 12.0868 | 13.0062   | 19.8944 |
| 2.0307        | 1.01  | 10000 | 2.0865          | 12.9732 | 8.5554 | 12.0287 | 12.8468   | 19.9712 |
| 1.8416        | 1.12  | 11000 | 2.0670          | 13.1366 | 8.6049 | 12.2127 | 13.0122   | 19.9184 |
| 1.9564        | 1.22  | 12000 | 2.0494          | 12.664  | 8.4708 | 11.8496 | 12.5582   | 19.9856 |
| 1.8846        | 1.32  | 13000 | 2.0231          | 13.3412 | 8.9207 | 12.4697 | 13.2275   | 19.9904 |
| 1.8347        | 1.42  | 14000 | 2.0383          | 12.5847 | 8.3611 | 11.6671 | 12.4601   | 20.0    |
| 1.8773        | 1.52  | 15000 | 1.9892          | 12.6655 | 8.2128 | 11.7945 | 12.5593   | 19.9592 |
| 1.8015        | 1.62  | 16000 | 1.9959          | 13.0598 | 8.7329 | 12.1663 | 12.9552   | 19.9736 |
| 1.8119        | 1.72  | 17000 | 1.9758          | 12.7897 | 8.4912 | 11.8756 | 12.6557   | 20.0    |
| 1.8025        | 1.83  | 18000 | 1.9764          | 13.2535 | 8.8228 | 12.3222 | 13.1407   | 19.948  |
| 1.8417        | 1.93  | 19000 | 1.9613          | 12.5747 | 8.3244 | 11.6604 | 12.4882   | 19.9712 |
| 1.6609        | 2.03  | 20000 | 1.9648          | 12.7294 | 8.4078 | 11.8369 | 12.6136   | 20.0    |
| 1.5885        | 2.13  | 21000 | 1.9464          | 13.2406 | 8.9054 | 12.4006 | 13.1491   | 19.9688 |
| 1.6082        | 2.23  | 22000 | 1.9442          | 13.0069 | 8.6038 | 12.1138 | 12.9006   | 20.0    |
| 1.5773        | 2.33  | 23000 | 1.9340          | 12.6373 | 8.3122 | 11.7935 | 12.5309   | 20.0    |
| 1.6535        | 2.43  | 24000 | 1.9432          | 13.1702 | 8.8258 | 12.2924 | 13.0442   | 19.9712 |
| 1.5923        | 2.53  | 25000 | 1.9226          | 13.2556 | 8.9101 | 12.3433 | 13.136    | 19.9648 |
| 1.4997        | 2.64  | 26000 | 1.9128          | 13.0711 | 8.6794 | 12.1325 | 12.9455   | 19.9904 |
| 1.574         | 2.74  | 27000 | 1.9093          | 13.1309 | 8.7958 | 12.2906 | 13.0341   | 19.9904 |
| 1.6254        | 2.84  | 28000 | 1.8991          | 12.8586 | 8.5662 | 12.0449 | 12.7786   | 19.9832 |
| 1.6427        | 2.94  | 29000 | 1.8905          | 12.7339 | 8.5642 | 11.9439 | 12.6131   | 19.996  |
| 1.3442        | 3.04  | 30000 | 1.9000          | 12.818  | 8.5827 | 11.9443 | 12.6917   | 20.0    |
| 1.466         | 3.14  | 31000 | 1.8990          | 12.9079 | 8.6233 | 12.0834 | 12.7858   | 19.9864 |
| 1.4822        | 3.24  | 32000 | 1.8937          | 13.2885 | 9.061  | 12.4811 | 13.1978   | 19.952  |
| 1.4399        | 3.35  | 33000 | 1.8927          | 13.0858 | 8.8237 | 12.2749 | 12.974    | 19.9624 |
| 1.3888        | 3.45  | 34000 | 1.8776          | 12.955  | 8.7827 | 12.1243 | 12.8524   | 19.9864 |
| 1.4031        | 3.55  | 35000 | 1.8816          | 12.8846 | 8.6634 | 11.9851 | 12.775    | 19.9904 |
| 1.4458        | 3.65  | 36000 | 1.8732          | 12.8441 | 8.5444 | 11.9473 | 12.728    | 19.9784 |
| 1.401         | 3.75  | 37000 | 1.8734          | 12.8671 | 8.616  | 12.0224 | 12.7432   | 19.9568 |
| 1.3798        | 3.85  | 38000 | 1.8664          | 12.7505 | 8.5224 | 11.8733 | 12.6269   | 19.9904 |
| 1.4413        | 3.95  | 39000 | 1.8656          | 12.8364 | 8.609  | 11.9612 | 12.7237   | 19.9904 |


### Framework versions


- Transformers 4.16.0.dev0
- Pytorch 1.7.0
- Datasets 1.17.0
- Tokenizers 0.11.0


model name: finetuned-BART-UK-financial-summarization-multiple-references


model author: nadzma


task: text2text-generation


tags: pytorch, bart, text2text-generation, transformers, license:apache-2.0, generated_from_trainer, model-index, autonlp_compatible


language:


- qu
tags:
- Llamacha


# QuBERTa


QuBERTa es un modelo de lenguaje basado en RoBERTa para el quechua. Nuestro modelo de lenguaje fue pre-entrenado con 5M de tokens del quechua sureño (Collao y Chanka).


El modelo utiliza un tokenizador Byte-level BPE con un vocabulario de 52000 tokens de subpalabras.


## Usabilidad


Una vez descargado los pesos y el tokenizador es necesario adjuntarlo en un sola carpeta, en este caso fue `QuBERTa `.


```python
from transformers import pipeline

fill_mask = pipeline(
    "fill-mask",
    model="./QuBERTa",
    tokenizer="./QuBERTa"
)
```


Se hace la prueba, la cual esta en fases de mejoras.


```python
fill_mask("allinllachu <mask> allinlla huk wasipita.")
```


    [{'score': 0.23992203176021576,
     'sequence': 'allinllachu nisqaqa allinlla huk wasipita.',
     'token': 334,
     'token_str': ' nisqaqa'},
    {'score': 0.061005301773548126,
     'sequence': 'allinllachu, allinlla huk wasipita.',
     'token': 16,
     'token_str': ','},
     {'score': 0.028720015659928322,
     'sequence': "allinllachu' allinlla huk wasipita.",
     'token': 11,
     'token_str': "'"},
    {'score': 0.012927944771945477,
    'sequence': 'allinllachu kay allinlla huk wasipita.',
    'token': 377,
    'token_str': ' kay'},
    {'score': 0.01230092253535986,
    'sequence': 'allinllachu. allinlla huk wasipita.',
     'token': 18,
    'token_str': '.'}]


model name: QuBERTa


model author: Llamacha


task: fill-mask


tags: pytorch, roberta, fill-mask, qu, transformers, Llamacha, autonlp_compatible, infinity_compatible


tags:


- conversational


# Pickle Rick DialoGPT Model


model name: DialoGPT-small-PickleRick


model author: ItzJorinoPlays


task: conversational


tags: pytorch, gpt2, text-generation, transformers, conversational


1
import cv2
2
import torch
3
import gradio as gr
4
import numpy as np
5
from PIL import Image
6
7
torch.hub.download_url_to_file('https://images.unsplash.com/photo-1437622368342-7a3d73a34c8f', 'turtle.jpg')
8
torch.hub.download_url_to_file('https://images.unsplash.com/photo-1519066629447-267fffa62d4b', 'lions.jpg')
9
10
midas = torch.hub.load("intel-isl/MiDaS", "MiDaS")
11
12
use_large_model = True
13
14
if use_large_model:
15
midas = torch.hub.load("intel-isl/MiDaS", "MiDaS")
16
else:
17
midas = torch.hub.load("intel-isl/MiDaS", "MiDaS_small")
18
19
device = "cpu"
20
midas.to(device)
21
22
midas_transforms = torch.hub.load("intel-isl/MiDaS", "transforms")
23
24
if use_large_model:
25
transform = midas_transforms.default_transform
26
else:
27
transform = midas_transforms.small_transform
28
29
30
def depth(img):
31
cv_image = np.array(img)
32
img = cv2.cvtColor(cv_image, cv2.COLOR_BGR2RGB)
33
34
input_batch = transform(img).to(device)
35
with torch.no_grad():
36
prediction = midas(input_batch)
37
38
prediction = torch.nn.functional.interpolate(
39
prediction.unsqueeze(1),
40
size=img.shape[:2],
41
mode="bicubic",
42
align_corners=False,
43
).squeeze()
44


45
output = prediction.cpu().numpy()
46
formatted = (output * 255 / np.max(output)).astype('uint8')
47
img = Image.fromarray(formatted)
48
return img
49


50
51
inputs =  gr.inputs.Image(type='pil', label="Original Image")
52
outputs = gr.outputs.Image(type="pil",label="Output Image")
53
54
title = "MiDaS"
55
description = "Gradio demo for MiDaS v2.1 which takes in a single image for computing relative depth. To use it, simply upload your image, or click one of the examples to load them. Read more at the links below."
56
article = "
Towards Robust Monocular Depth Estimation: Mixing Datasets for Zero-shot Cross-dataset Transfer | Github Repo
"
57
58
examples = [
59
["turtle.jpg"],
60
["lions.jpg"]
61
]
62
63
gr.Interface(depth, inputs, outputs, title=title, description=description, article=article, examples=examples, analytics_enabled=False).launch(debug=True)


model name: Depthmap


model author: MrBodean


tags: arxiv:1907.01341


license: mit
tags:


- generated_from_trainer
datasets:
- amazon_reviews_multi
model-index:
- name: xlm-roberta-base-finetuned-marc-en
results: []


<!-- This model card has been generated automatically according to the information the Trainer had access to. You
should probably proofread and complete it, then remove this comment. -->


# xlm-roberta-base-finetuned-marc-en


This model is a fine-tuned version of [xlm-roberta-base](https://huggingface.co/xlm-roberta-base) on the amazon_reviews_multi dataset.
It achieves the following results on the evaluation set:


- Loss: 0.8976
- Mae: 0.4268


## Model description


More information needed


## Intended uses & limitations


## Training and evaluation data


## Training procedure


### Training hyperparameters


The following hyperparameters were used during training:


- learning_rate: 2e-05
- train_batch_size: 16
- eval_batch_size: 16
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- num_epochs: 2


### Training results


| Training Loss | Epoch | Step | Validation Loss | Mae    |
|:-------------:|:-----:|:----:|:---------------:|:------:|
| 1.092         | 1.0   | 235  | 0.9514          | 0.5122 |
| 0.9509        | 2.0   | 470  | 0.8976          | 0.4268 |


### Framework versions


- Transformers 4.11.3
- Pytorch 1.9.0+cu111
- Datasets 1.14.0
- Tokenizers 0.10.3


model name: xlm-roberta-base-finetuned-marc-en


model author: d4niel92


task: text-classification


tags: pytorch, tensorboard, xlm-roberta, text-classification, dataset:amazon_reviews_multi, transformers, license:mit, generated_from_trainer, model-index


tags:


- generated_from_keras_callback
- dpr
license: apache-2.0
model-index:
- name: dpr-ctx_encoder_bert_uncased_L-12_H-128_A-2
results: []


<!-- This model card has been generated automatically according to the information Keras had access to. You should
probably proofread and complete it, then remove this comment. -->


# dpr-ctx_encoder_bert_uncased_L-2_H-128_A-2


This model(google/bert_uncased_L-2_H-128_A-2) was trained from scratch on training data: data.retriever.nq-adv-hn-train(facebookresearch/DPR).
It achieves the following results on the evaluation set:


## Evaluation data


evaluation dataset: facebook-dpr-dev-dataset from official DPR github


|model_name|data_name|num of queries|num of passages|R@10|R@20|R@50|R@100|R@100|
|---|---|---|---|---|---|---|---|---|
|nlpconnect/dpr-ctx_encoder_bert_uncased_L-2_H-128_A-2(our)|nq-dev dataset|6445|199795|60.53%|68.28%|76.07%|80.98%|91.45%|
|nlpconnect/dpr-ctx_encoder_bert_uncased_L-12_H-128_A-2(our)|nq-dev dataset|6445|199795|65.43%|71.99%|79.03%|83.24%|92.11%|
|*facebook/dpr-ctx_encoder-single-nq-base(hf/fb)|nq-dev dataset|6445|199795|40.94%|49.27%|59.05%|66.00%|82.00%|


evaluation dataset: UKPLab/beir test data but we have used first 2lac passage only.


|model_name|data_name|num of queries|num of passages|R@10|R@20|R@50|R@100|R@100|
|---|---|---|---|---|---|---|---|---|
|nlpconnect/dpr-ctx_encoder_bert_uncased_L-2_H-128_A-2(our)|nq-test dataset|3452|200001|49.68%|59.06%|69.40%|75.75%|89.28%|
|nlpconnect/dpr-ctx_encoder_bert_uncased_L-12_H-128_A-2(our)|nq-test dataset|3452|200001|51.62%|61.09%|70.10%|76.07%|88.70%|
|*facebook/dpr-ctx_encoder-single-nq-base(hf/fb)|nq-test dataset|3452|200001|32.93%|43.74%|56.95%|66.30%|83.92%|


Note: * means we have evaluated on same eval dataset.


### Usage (HuggingFace Transformers)


```python

passage_encoder = TFAutoModel.from_pretrained("nlpconnect/dpr-ctx_encoder_bert_uncased_L-12_H-128_A-2")
query_encoder = TFAutoModel.from_pretrained("nlpconnect/dpr-question_encoder_bert_uncased_L-12_H-128_A-2")

p_tokenizer = AutoTokenizer.from_pretrained("nlpconnect/dpr-ctx_encoder_bert_uncased_L-12_H-128_A-2")
q_tokenizer = AutoTokenizer.from_pretrained("nlpconnect/dpr-question_encoder_bert_uncased_L-12_H-128_A-2")

def get_title_text_combined(passage_dicts):
    res = []
    for p in passage_dicts:
        res.append(tuple((p['title'], p['text'])))
    return res

processed_passages = get_title_text_combined(passage_dicts)

def extracted_passage_embeddings(processed_passages, model_config):
    passage_inputs = tokenizer.batch_encode_plus(
                    processed_passages,
                    add_special_tokens=True,
                    truncation=True,
                    padding="max_length",
                    max_length=model_config.passage_max_seq_len,
                    return_token_type_ids=True
                )
    passage_embeddings = passage_encoder.predict([np.array(passage_inputs['input_ids']),
                                                np.array(passage_inputs['attention_mask']),
                                                np.array(passage_inputs['token_type_ids'])],
                                                batch_size=512,
                                                verbose=1)
    return passage_embeddings

passage_embeddings = extracted_passage_embeddings(processed_passages, model_config)

def extracted_query_embeddings(queries, model_config):
    query_inputs = tokenizer.batch_encode_plus(
                    queries,
                    add_special_tokens=True,
                    truncation=True,
                    padding="max_length",
                    max_length=model_config.query_max_seq_len,
                    return_token_type_ids=True
                )
    query_embeddings = query_encoder.predict([np.array(query_inputs['input_ids']),
                                                np.array(query_inputs['attention_mask']),
                                                np.array(query_inputs['token_type_ids'])],
                                                batch_size=512,
                                                verbose=1)
    return query_embeddings

query_embeddings = extracted_query_embeddings(queries, model_config)

```


### Training hyperparameters


- optimizer: None
- training_precision: float32


### Framework versions


- Transformers 4.15.0
- TensorFlow 2.7.0
- Tokenizers 0.10.3


model name: dpr-ctx_encoder_bert_uncased_L-2_H-128_A-2


model author: nlpconnect


task: feature-extraction


tags: pytorch, tf, bert, feature-extraction, transformers, generated_from_keras_callback, dpr, license:apache-2.0, model-index, infinity_compatible


tags:


- qa
license: apache-2.0
datasets:
- squad_v2
- natural_questions


# Roberta-base-Squad2-NQ


## What is SQuAD?


Stanford Question Answering Dataset (SQuAD) is a reading comprehension dataset, consisting of questions posed by crowdworkers on a set of Wikipedia articles, where the answer to every question is a segment of text, or span, from the corresponding reading passage, or the question might be unanswerable.


SQuAD2.0 combines the 100,000 questions in SQuAD1.1 with over 50,000 unanswerable questions written adversarially by crowdworkers to look similar to answerable ones. To do well on SQuAD2.0, systems must not only answer questions when possible, but also determine when no answer is supported by the paragraph and abstain from answering.


## The Natural Questions Dataset


To help spur development in open-domain question answering, we have created the Natural Questions (NQ) corpus, along with a challenge website based on this data. The NQ corpus contains questions from real users, and it requires QA systems to read and comprehend an entire Wikipedia article that may or may not contain the answer to the question. The inclusion of real user questions, and the requirement that solutions should read an entire page to find the answer, cause NQ to be a more realistic and challenging task than prior QA datasets.


## Training


Firstly, we took base roberta model and trained on SQuQD 2.0 dataset for 2 epoch and then after we took NQ Small answer and trained for 1 epoch.


Total Dataset Size: 204416 Examples from squadv2 and NQ Small answer dataset


## Evaluation


Eval Dataset: Squadv2 dev


```
  {'exact': 80.2998399730481,
   'f1': 83.4402145786235,
   'total': 11873,
   'HasAns_exact': 79.08232118758434,
   'HasAns_f1': 85.37207619635592,
   'HasAns_total': 5928,
   'NoAns_exact': 81.5138772077376,
   'NoAns_f1': 81.5138772077376,
   'NoAns_total': 5945,
   'best_exact': 80.2998399730481,
   'best_exact_thresh': 0.0,
   'best_f1': 83.44021457862335,
   'best_f1_thresh': 0.0}
```


model name: roberta-base-squad2-nq


model author: nlpconnect


task: question-answering


tags: pytorch, jax, roberta, question-answering, dataset:squad_v2, dataset:natural_questions, transformers, qa, license:apache-2.0, autonlp_compatible, infinity_compatible


tags:


- image-captioning
license: apache-2.0


# nlpconnect/vit-gpt2-image-captioning


This is an image captioning model training by @ydshieh in flax, this is pytorch version of https://huggingface.co/ydshieh/vit-gpt2-coco-en-ckpts model.


# Sample running code


```python

from transformers import VisionEncoderDecoderModel, ViTFeatureExtractor, AutoTokenizer

model = VisionEncoderDecoderModel.from_pretrained("nlpconnect/vit-gpt2-image-captioning")
feature_extractor = ViTFeatureExtractor.from_pretrained("nlpconnect/vit-gpt2-image-captioning")
tokenizer = AutoTokenizer.from_pretrained("nlpconnect/vit-gpt2-image-captioning")

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)

max_length = 16
num_beams = 4
gen_kwargs = {"max_length": max_length, "num_beams": num_beams}
def predict_step(image_paths):
  images = []
  for image_path in image_paths:
    i_image = Image.open(image_path)
    if i_image.mode != "RGB":
      i_image = i_image.convert(mode="RGB")

    images.append(i_image)

  pixel_values = feature_extractor(images=images, return_tensors="pt").pixel_values
  pixel_values = pixel_values.to(device)

  output_ids = model.generate(pixel_values, **gen_kwargs)

  preds = tokenizer.batch_decode(output_ids, skip_special_tokens=True)
  preds = [pred.strip() for pred in preds]
  return preds

predict_step(['doctor.e16ba4e4.jpg'] # ['a woman in a hospital bed with a woman in a hospital bed']

```


model name: vit-gpt2-image-captioning


tags: pytorch, vision-encoder-decoder, transformers, image-captioning, license:apache-2.0


- generated_from_keras_callback
- dpr
license: apache-2.0
model-index:
- name: dpr-question_encoder_bert_uncased_L-2_H-128_A-2
results: []


<!-- This model card has been generated automatically according to the information Keras had access to. You should
probably proofread and complete it, then remove this comment. -->


# dpr-question_encoder_bert_uncased_L-2_H-128_A-2


This model(google/bert_uncased_L-2_H-128_A-2) was trained from scratch on training data: data.retriever.nq-adv-hn-train(facebookresearch/DPR).
It achieves the following results on the evaluation set:


## Evaluation data


evaluation dataset: facebook-dpr-dev-dataset from official DPR github


|model_name|data_name|num of queries|num of passages|R@10|R@20|R@50|R@100|R@100|
|---|---|---|---|---|---|---|---|---|
|nlpconnect/dpr-ctx_encoder_bert_uncased_L-2_H-128_A-2(our)|nq-dev dataset|6445|199795|60.53%|68.28%|76.07%|80.98%|91.45%|
|nlpconnect/dpr-ctx_encoder_bert_uncased_L-12_H-128_A-2(our)|nq-dev dataset|6445|199795|65.43%|71.99%|79.03%|83.24%|92.11%|
|*facebook/dpr-ctx_encoder-single-nq-base(hf/fb)|nq-dev dataset|6445|199795|40.94%|49.27%|59.05%|66.00%|82.00%|


evaluation dataset: UKPLab/beir test data but we have used first 2lac passage only.


|model_name|data_name|num of queries|num of passages|R@10|R@20|R@50|R@100|R@100|
|---|---|---|---|---|---|---|---|---|
|nlpconnect/dpr-ctx_encoder_bert_uncased_L-2_H-128_A-2(our)|nq-test dataset|3452|200001|49.68%|59.06%|69.40%|75.75%|89.28%|
|nlpconnect/dpr-ctx_encoder_bert_uncased_L-12_H-128_A-2(our)|nq-test dataset|3452|200001|51.62%|61.09%|70.10%|76.07%|88.70%|
|*facebook/dpr-ctx_encoder-single-nq-base(hf/fb)|nq-test dataset|3452|200001|32.93%|43.74%|56.95%|66.30%|83.92%|


Note: * means we have evaluated on same eval dataset.


### Usage (HuggingFace Transformers)


```python

passage_encoder = TFAutoModel.from_pretrained("nlpconnect/dpr-ctx_encoder_bert_uncased_L-12_H-128_A-2")
query_encoder = TFAutoModel.from_pretrained("nlpconnect/dpr-question_encoder_bert_uncased_L-12_H-128_A-2")

p_tokenizer = AutoTokenizer.from_pretrained("nlpconnect/dpr-ctx_encoder_bert_uncased_L-12_H-128_A-2")
q_tokenizer = AutoTokenizer.from_pretrained("nlpconnect/dpr-question_encoder_bert_uncased_L-12_H-128_A-2")

def get_title_text_combined(passage_dicts):
    res = []
    for p in passage_dicts:
        res.append(tuple((p['title'], p['text'])))
    return res

processed_passages = get_title_text_combined(passage_dicts)

def extracted_passage_embeddings(processed_passages, model_config):
    passage_inputs = tokenizer.batch_encode_plus(
                    processed_passages,
                    add_special_tokens=True,
                    truncation=True,
                    padding="max_length",
                    max_length=model_config.passage_max_seq_len,
                    return_token_type_ids=True
                )
    passage_embeddings = passage_encoder.predict([np.array(passage_inputs['input_ids']),
                                                np.array(passage_inputs['attention_mask']),
                                                np.array(passage_inputs['token_type_ids'])],
                                                batch_size=512,
                                                verbose=1)
    return passage_embeddings

passage_embeddings = extracted_passage_embeddings(processed_passages, model_config)

def extracted_query_embeddings(queries, model_config):
    query_inputs = tokenizer.batch_encode_plus(
                    queries,
                    add_special_tokens=True,
                    truncation=True,
                    padding="max_length",
                    max_length=model_config.query_max_seq_len,
                    return_token_type_ids=True
                )
    query_embeddings = query_encoder.predict([np.array(query_inputs['input_ids']),
                                                np.array(query_inputs['attention_mask']),
                                                np.array(query_inputs['token_type_ids'])],
                                                batch_size=512,
                                                verbose=1)
    return query_embeddings

query_embeddings = extracted_query_embeddings(queries, model_config)

```


### Training hyperparameters


The following hyperparameters were used during training:


- optimizer: None
- training_precision: float32


### Framework versions


- Transformers 4.15.0
- TensorFlow 2.7.0
- Tokenizers 0.10.3


model name: dpr-question_encoder_bert_uncased_L-2_H-128_A-2


model author: nlpconnect


task: feature-extraction


tags: pytorch, tf, bert, feature-extraction, transformers, generated_from_keras_callback, dpr, license:apache-2.0, model-index, infinity_compatible


      {'author': 'P50',
       'capital': 'P36',
       'child': 'P40',
       'country': 'P17',
       'country of origin': 'P495',
       'creator': 'P170',
       'educated at': 'P69',
       'founder': 'P112',
       'genre': 'P136',
       'headquarters location': 'P159',
       'language of work or name': 'P407',
       'located in the administrative territorial entity': 'P131',
       'location': 'P276',
       'location of formation': 'P740',
       'manufacturer': 'P176',
       'notable work': 'P800',
       'occupation': 'P106',
       'owned by': 'P127',
       'performer': 'P175',
       'place of birth': 'P19',
       'place of death': 'P20',
       'position played on team / speciality': 'P413',
       'record label': 'P264',
       'spouse': 'P26'}

       1250/1250 [==============================] - 159s 116ms/step - loss: 0.2096 - accuracy: 0.9570 - val_loss: 0.0407 - val_accuracy: 0.9805

       from transformers import pipeline
       classfier = pipeline("text-classification", model="nlpconnect/distilbert-base-cased-wikiproperties-classifier")


model name: distilbert-base-cased-wikiproperties-classifier


task: text-classification


tags: tf, distilbert, text-classification, transformers, infinity_compatible


language:


- en
- he
tags:
- generated_from_trainer
metrics:
- bleu
model-index:
- name: output_base
results: []


<!-- This model card has been generated automatically according to the information the Trainer had access to. You
should probably proofread and complete it, then remove this comment. -->


# output_base


This model is a fine-tuned version of [/home/ec2-user/SageMaker/marian_base](https://huggingface.co//home/ec2-user/SageMaker/marian_base) on the None dataset.
It achieves the following results on the evaluation set:


- Loss: 1.6852
- Bleu: 30.5903
- Gen Len: 64.8182


## Model description


More information needed


## Intended uses & limitations


## Training and evaluation data


## Training procedure


### Training hyperparameters


- learning_rate: 5e-05
- train_batch_size: 48
- eval_batch_size: 16
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- num_epochs: 10.0
- mixed_precision_training: Native AMP


### Training results


| Training Loss | Epoch | Step    | Validation Loss | Bleu    | Gen Len |
|:-------------:|:-----:|:-------:|:---------------:|:-------:|:-------:|
| 1.9938        | 1.0   | 188563  | 2.0008          | 27.6169 | 66.0246 |
| 1.8171        | 2.0   | 377126  | 1.8753          | 28.4709 | 65.8859 |
| 1.7389        | 3.0   | 565689  | 1.8120          | 28.9724 | 65.8601 |
| 1.6893        | 4.0   | 754252  | 1.7690          | 29.5248 | 65.8846 |
| 1.6559        | 5.0   | 942815  | 1.7467          | 29.5757 | 65.8046 |
| 1.6279        | 6.0   | 1131378 | 1.7236          | 29.7512 | 66.0482 |
| 1.6053        | 7.0   | 1319941 | 1.7137          | 29.916  | 66.0031 |
| 1.5871        | 8.0   | 1508504 | 1.7007          | 30.1671 | 65.8853 |
| 1.5694        | 9.0   | 1697067 | 1.6921          | 30.3613 | 65.9506 |
| 1.5539        | 10.0  | 1885630 | 1.6852          | 30.4049 | 66.0487 |


### Framework versions


- Transformers 4.12.0.dev0
- Pytorch 1.9.1+cu102
- Datasets 1.12.1
- Tokenizers 0.10.3


model name: en_he_base


model author: orendar


task: text2text-generation


tags: pytorch, marian, text2text-generation, en, he, transformers, generated_from_trainer, model-index, autonlp_compatible


language:


- en
- he
tags:
- generated_from_trainer
metrics:
- bleu
model-index:
- name: output_large
results: []


# output_large


This model is a fine-tuned version of [/home/ec2-user/SageMaker/marian_large](https://huggingface.co//home/ec2-user/SageMaker/marian_large) on the None dataset.
It achieves the following results on the evaluation set:


- Loss: 1.5473
- Bleu: 32.6637
- Gen Len: 64.8596


## Model description


More information needed


## Intended uses & limitations


## Training and evaluation data


## Training procedure


### Training hyperparameters


The following hyperparameters were used during training:


- learning_rate: 5e-05
- train_batch_size: 16
- eval_batch_size: 16
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- num_epochs: 10.0
- mixed_precision_training: Native AMP


### Training results


| Training Loss | Epoch | Step    | Validation Loss | Bleu    | Gen Len |
|:-------------:|:-----:|:-------:|:---------------:|:-------:|:-------:|
| 1.7986        | 1.0   | 565689  | 1.8566          | 28.7509 | 66.1132 |
| 1.6695        | 2.0   | 1131378 | 1.7653          | 29.525  | 66.2651 |
| 1.6038        | 3.0   | 1697067 | 1.7081          | 29.8841 | 66.1849 |
| 1.5515        | 4.0   | 2262756 | 1.6601          | 30.588  | 65.9093 |
| 1.5115        | 5.0   | 2828445 | 1.6359          | 30.9726 | 66.2171 |
| 1.474         | 6.0   | 3394134 | 1.6097          | 31.3244 | 66.1843 |
| 1.4425        | 7.0   | 3959823 | 1.5914          | 31.557  | 66.1481 |
| 1.4063        | 8.0   | 4525512 | 1.5666          | 32.0886 | 65.8595 |
| 1.3724        | 9.0   | 5091201 | 1.5537          | 32.3644 | 66.1648 |
| 1.3452        | 10.0  | 5656890 | 1.5473          | 32.4724 | 66.1539 |


### Framework versions


model name: en_he_large


model author: orendar


task: text2text-generation


language:


- en
tags:
- text generation
- pytorch
- causal-lm
license: apache-2.0
datasets:
- custom


# GPT-Neo 125M finetuned with beer recipes


## Model Description


GPT-Neo 125M is a transformer model based on EleutherAI's replication of the GPT-3 architecture https://huggingface.co/EleutherAI/gpt-neo-125M.
It generates recipes for brewing beer in a YAML-like format which can be easily used for different purposes.


Is it useful? Not sure - but it was really fun to create it :laughing:


## Training data


This model was trained on a custom dataset of ~ 76,800 beer recipes from the internet. It includes recipes for the following
styles of beer:


* Strong American Ale
* Pale American Ale
* India Pale Ale (IPA)
* Standard American Beer
* Stout
* English Pale Ale
* IPA
* American Porter and Stout
* Sour Ale
* Irish Beer
* Strong British Ale
* Belgian and French Ale
* German Wheat and Rye Beer
* Czech Lager
* Spice/Herb/Vegetable Beer
* Specialty Beer
* American Ale
* Pilsner
* Belgian Ale
* Strong Belgian Ale
* Bock
* Brown British Beer
* German Wheat Beer
* Fruit Beer
* Amber Malty European Lager
* Pale Malty European Lager
* British Bitter
* Amber and Brown American Beer
* Light Hybrid Beer
* Pale Commonwealth Beer
* American Wild Ale
* European Amber Lager
* Belgian Strong Ale
* International Lager
* Amber Bitter European Lager
* Light Lager
* Scottish and Irish Ale
* European Sour Ale
* Trappist Ale
* Strong European Beer
* Porter
* Historical Beer
* Pale Bitter European Beer
* Amber Hybrid Beer
* Smoke Flavored/Wood-Aged Beer
* Spiced Beer
* Dark European Lager
* Alternative Fermentables Beer
* Mead
* Strong Ale
* Dark British Beer
* Scottish Ale
* Smoked Beer
* English Brown Ale
* Dark Lager
* Cider or Perry
* Wood Beer


### How to use


You can use this model directly with a pipeline for text generation. This example generates a different recipe each time it's run:


```py
>>> from transformers import pipeline
>>> generator = pipeline('text-generation', model='b3ck1/gpt-neo-125M-finetuned-beer-recipes')
>>> generator("style: Pilsner\nbatch_size: 20\nefficiency: 75\nboil_size:", do_sample=True, min_length=50, max_length=500)
>>> print(output[0]['generated_text'])

style: Pilsner
batch_size: 20
efficiency: 70
boil_size: 24
boil_time: 60
fermentables:
- name: Pale Ale
  type: Grain
  amount: 6.5
hops:
- name: Saaz
  alpha: 3.5
  use: Boil
  time: 60
  amount: 0.06
- name: Saaz
  alpha: 3.5
  use: Boil
  time: 30
  amount: 0.06
- name: Saaz
  alpha: 3.5
  use: Boil
  time: 10
  amount: 0.06
- name: Saaz
  alpha: 3.5
  use: Boil
  time: 0
  amount: 0.06
yeasts:
- name: Safale - American Ale Yeast US-05
  amount: 0.11
  min_temperature: 12
  max_temperature: 25
primary_temp: null
mash_steps:
- step_temp: 65
  step_time: 60
miscs: []
```


### See this model in action


This model was used to build https://beerai.net.


model name: gpt-neo-125M-finetuned-beer-recipes


model author: b3ck1


task: text-generation


tags: pytorch, gpt_neo, text-generation, en, dataset:custom, transformers, text generation, causal-lm, license:apache-2.0


I'm just testing this hugging face thing out, wish me luck!


model name: recommender-demo


model author: seyia92coding


tags:


license: mit
tags:


- generated_from_trainer
model-index:
- name: output
results: []


<!-- This model card has been generated automatically according to the information the Trainer had access to. You
should probably proofread and complete it, then remove this comment. -->


# output


This model is a fine-tuned version of [gpt2](https://huggingface.co/gpt2) on a dataset of Shakespeare's plays.


## Model description


The model is the original gpt-2 model fine-tuned on a custom dataset.


## Intended uses & limitations


The model can be used to generate Shakespearean-like text. Consider that because it comes from plays, such a typographical structure might be reproduced.


## Training and evaluation data


Trained with Shakespeare's plays corpus.


## Training procedure


### Training hyperparameters


The following hyperparameters were used during training:


- learning_rate: 5e-05
- train_batch_size: 1
- eval_batch_size: 8
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- num_epochs: 2.0


### Training results


### Framework versions


- Transformers 4.16.0.dev0
- Pytorch 1.10.0+cu111
- Datasets 1.18.0
- Tokenizers 0.11.0


model name: Shakespear-GPT2


model author: Iacopo


task: text-generation


tags: pytorch, gpt2, text-generation, transformers, license:mit, generated_from_trainer, model-index


tags:


- conversational


# Peter Griffin DialoGPT Model


model name: DialoGPT-small-petergriffin


model author: person123


task: conversational


tags: pytorch, gpt2, text-generation, transformers, conversational


model name: ryan-sackmott


model author: gwima


- image-classification
- pytorch
- huggingpics
metrics:
- accuracy


model-index:


- name: bee-likes
results:
  - task:
name: Image Classification
type: image-classification
metrics:
    - name: Accuracy
type: accuracy
value: 0.8333333134651184


# bee-likes


Autogenerated by HuggingPics🤗🖼


Create your own image classifier for **anything** by running [the demo on Google Colab](https://colab.research.google.com/github/nateraw/huggingpics/blob/main/HuggingPics.ipynb).


Report any issues with the demo at the [github repo](https://github.com/nateraw/huggingpics).


## Example Images


#### bee


![bee](images/bee.jpg)


#### hoverfly


![hoverfly](images/hoverfly.jpg)


#### wasp


![wasp](images/wasp.jpg)


model name: bee-likes


model author: Frodnar


task: image-classification


tags: pytorch, tensorboard, vit, image-classification, transformers, huggingpics, model-index


## license: artistic-2.0


model name: RRHood


model author: Duael


tags: license:artistic-2.0


language: vi
datasets:


- common_voice
- FOSD: https://data.mendeley.com/datasets/k9sxg2twv4/4
metrics:
- wer
tags:
- audio
- automatic-speech-recognition
- speech
- xlsr-fine-tuning-week
license: apache-2.0
model-index:
- name: XLSR Wav2Vec2 Vietnamese by Ontocord
results:
  - task:
name: Speech Recognition
type: automatic-speech-recognition
dataset:
name: Common Voice vi
type: common_voice
args: vi
metrics:
    - name: Test WER
type: wer
value: 42.403315


# Ontocord/Wav2Vec2-Large-XLSR-53-Vietnamese


Fine-tuned [facebook/wav2vec2-large-xlsr-53](https://huggingface.co/facebook/wav2vec2-large-xlsr-53) on Vietnamese using the [Common Voice](https://huggingface.co/datasets/common_voice), [FOSD](https://data.mendeley.com/datasets/k9sxg2twv4/4).
When using this model, make sure that your speech input is sampled at 16kHz.


## Usage


The model can be used directly (without a language model) as follows:


```
import torch
import torchaudio
from datasets import load_dataset
from transformers import Wav2Vec2ForCTC, Wav2Vec2Processor

test_dataset = load_dataset("common_voice", "vi", split="test[:2%]")

processor = Wav2Vec2Processor.from_pretrained("ontocord/wav2vec2-large-xlsr-53-vietnamese")
model = Wav2Vec2ForCTC.from_pretrained("ontocord/wav2vec2-large-xlsr-53-vietnamese")

resampler = torchaudio.transforms.Resample(48_000, 16_000)

# Preprocessing the datasets.
# We need to read the aduio files as arrays
def speech_file_to_array_fn(batch):
	speech_array, sampling_rate = torchaudio.load(batch["path"])
	batch["speech"] = resampler(speech_array).squeeze().numpy()
	return batch

test_dataset = test_dataset.map(speech_file_to_array_fn)
inputs = processor(test_dataset["speech"][:2], sampling_rate=16_000, return_tensors="pt", padding=True)

with torch.no_grad():
	logits = model(inputs.input_values, attention_mask=inputs.attention_mask).logits

predicted_ids = torch.argmax(logits, dim=-1)

print("Prediction:", processor.batch_decode(predicted_ids))
print("Reference:", test_dataset["sentence"][:2])
```


## Evaluation


The model can be evaluated as follows on the Vietnamese test data of Common Voice.


```

import torch
import torchaudio
from datasets import load_dataset, load_metric
from transformers import Wav2Vec2ForCTC, Wav2Vec2Processor
import re

test_dataset = load_dataset("common_voice", "vi", split="test")
wer = load_metric("wer")
processor = Wav2Vec2Processor.from_pretrained("ontocord/wav2vec2-large-xlsr-vietnamese")
model = Wav2Vec2ForCTC.from_pretrained("ontocord/wav2vec2-large-xlsr-vietnamese")
model.to("cuda")

chars_to_ignore_regex = '[\\\+\@\ǀ\,\?\.\!\-\;\:\"\“\%\‘\”\�]'
resampler = torchaudio.transforms.Resample(48_000, 16_000)

# Preprocessing the datasets.
# We need to read the aduio files as arrays
def speech_file_to_array_fn(batch):
  batch["sentence"] = re.sub(chars_to_ignore_regex, '', batch["sentence"]).lower()
  speech_array, sampling_rate = torchaudio.load(batch["path"])
  batch["speech"] = resampler(speech_array).squeeze().numpy()
  return batch

test_dataset = test_dataset.map(speech_file_to_array_fn)

# you may also want to use the  decode_string from https://huggingface.co/Nhut/wav2vec2-large-xlsr-vietnamese
def evaluate(batch):
  inputs = processor(batch["speech"], sampling_rate=16_000, return_tensors="pt", padding=True)
  with torch.no_grad():
    logits = model(inputs.input_values.to("cuda"), attention_mask=inputs.attention_mask.to("cuda")).logits
  pred_ids = torch.argmax(logits, dim=-1)
  batch["pred_strings"] = processor.batch_decode(pred_ids)
  return batch

result = test_dataset.map(evaluate, batched=True, batch_size=8)
print("WER: {:2f}".format(100 * wer.compute(predictions=result["pred_strings"], references=result["sentence"])))

```


**Test Result**: 42.403315


## Training


The Common Voice train, validation, and FPT datasets were used for training.


The script used for training can be found here # TODO


model name: wav2vec2-large-xlsr-vietnamese


model author: ontocord


task: automatic-speech-recognition


tags: pytorch, wav2vec2, automatic-speech-recognition, vi, transformers, audio, speech, xlsr-fine-tuning-week, license:apache-2.0, model-index


language: vi
datasets:


- common_voice
- FOSD: https://data.mendeley.com/datasets/k9sxg2twv4/4
metrics:
- wer
tags:
- language-modeling
- audio
- automatic-speech-recognition
- speech
- xlsr-fine-tuning-week
license: apache-2.0
model-index:
- name: MT5 Fix Asr Vietnamese by Ontocord
results:
  - task:
name: Speech Recognition
type: automatic-speech-recognition
dataset:
name: Common Voice vi
type: common_voice
args: vi
metrics:
    - name: Test WER
type: wer
value: 25.207182


# Ontocord/mt5-fix-asr-vietnamese


Fine-tuned mt5 to correct output of an ASR model trained on [facebook/wav2vec2-large-xlsr-53](https://huggingface.co/facebook/wav2vec2-large-xlsr-53) which was trained on Vietnamese using the [Common Voice](https://huggingface.co/datasets/common_voice), and [FOSD](https://data.mendeley.com/datasets/k9sxg2twv4/4).


## Usage


The model can be used directly by submitting vietnamese asr text, but is is best to use with the ontocord/wav2vec2-large-xlsr-vietnamese model.


```
import torch
import torchaudio
from datasets import load_dataset
from transformers import Wav2Vec2ForCTC, Wav2Vec2Processor, pipelines

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
test_dataset = load_dataset("common_voice", "vi", split="test[:2%]")
processor = Wav2Vec2Processor.from_pretrained("ontocord/wav2vec2-large-xlsr-53-vietnamese")
model = Wav2Vec2ForCTC.from_pretrained("ontocord/wav2vec2-large-xlsr-53-vietnamese").to(device)
mt5 = pipelines.pipeline("text2text-generation","ontocord/mt5-fix-asr-vietnamese", device=0 if device == "cuda" else -1)
resampler = torchaudio.transforms.Resample(48_000, 16_000)
# Preprocessing the datasets.
# We need to read the aduio files as arrays
def speech_file_to_array_fn(batch):
	speech_array, sampling_rate = torchaudio.load(batch["path"])
	batch["speech"] = resampler(speech_array).squeeze().numpy()
	return batch
test_dataset = test_dataset.map(speech_file_to_array_fn)
inputs = processor(test_dataset["speech"][:2], sampling_rate=16_000, return_tensors="pt", padding=True)
with torch.no_grad():
	logits = model(inputs.input_values.to(device), attention_mask=inputs.attention_mask.to(device)).logits
predicted_ids = torch.argmax(logits, dim=-1)
print("Prediction:", [aHash['generated_text'] for aHash in mt5(processor.batch_decode(predicted_ids), max_length=100)])
print("Reference:", test_dataset["sentence"][:2])
```


## Evaluation


```
import torch
import torchaudio
from datasets import load_dataset, load_metric
from transformers import Wav2Vec2ForCTC, Wav2Vec2Processor, pipelines
import re
test_dataset = load_dataset("common_voice", "vi", split="test")
wer = load_metric("wer")

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
processor = Wav2Vec2Processor.from_pretrained("ontocord/wav2vec2-large-xlsr-vietnamese")
model = Wav2Vec2ForCTC.from_pretrained("ontocord/wav2vec2-large-xlsr-vietnamese").to(device)
mt5 = pipelines.pipeline("text2text-generation","ontocord/mt5-fix-asr-vietnamese", device=0 if device == "cuda" else -1)
chars_to_ignore_regex = '[\\\+\@\ǀ\,\?\.\!\-\;\:\"\“\%\‘\”\�]'
resampler = torchaudio.transforms.Resample(48_000, 16_000)

# Preprocessing the datasets.
# We need to read the aduio files as arrays
def speech_file_to_array_fn(batch):
  batch["sentence"] = re.sub(chars_to_ignore_regex, '', batch["sentence"]).lower()
  speech_array, sampling_rate = torchaudio.load(batch["path"])
  batch["speech"] = resampler(speech_array).squeeze().numpy()
  return batch
test_dataset = test_dataset.map(speech_file_to_array_fn)

# you may also want to use the  decode_string from https://huggingface.co/Nhut/wav2vec2-large-xlsr-vietnamese
def evaluate(batch):
  inputs = processor(batch["speech"], sampling_rate=16_000, return_tensors="pt", padding=True)
  with torch.no_grad():
    logits = model(inputs.input_values.to(device), attention_mask=inputs.attention_mask.to(device)).logits
    pred_ids = torch.argmax(logits, dim=-1)
    max_length = int(pred_ids.size()[1])
    txt = [aHash['generated_text'].strip() for aHash in mt5(processor.batch_decode(pred_ids), max_length=max_length)]
    batch["pred_strings"] = txt
  return batch
result = test_dataset.map(evaluate, batched=True, batch_size=8)
print("WER: {:2f}".format(100 * wer.compute(predictions=result["pred_strings"], references=result["sentence"])))
```


**Test Result**: 25.207182


## Training


The Common Voice train, validation, and FPT datasets were used for training.
The script used for training can be found here # TODO


model name: mt5-fix-asr-vietnamese


tags: pytorch, jax, mt5, vi, transformers, language-modeling, audio, automatic-speech-recognition, speech, xlsr-fine-tuning-week, license:apache-2.0, model-index


language: en
datasets:


- LJSpeech
- LibriTTS
tags:
- audio
- TTS
license: apache-2.0


# ontocord/fastspeech2-en


Modified version of the text-to-speech system [FastSpeech 2: Fast and High-Quality End-to-End Text to Speech] (https://arxiv.org/abs/2006.04558v1).


## Installation


```
git clone https://github.com/ontocord/fastspeech2_hf
pip install transformers torchaudio

```


The model can be used directly as follows:


```
# load the model and tokenizer
from fastspeech2_hf.modeling_fastspeech2 import FastSpeech2ForPretraining, FastSpeech2Tokenizer
model = FastSpeech2ForPretraining.from_pretrained("ontocord/fastspeech2-en")
tokenizer = FastSpeech2Tokenizer.from_pretrained("ontocord/fastspeech2-en")

# some helper routines
from IPython.display import Audio as IPAudio, display as IPdisplay
import torch
import torchaudio

def play_audio(waveform, sample_rate):
  waveform = waveform.numpy()
  if len(waveform.shape)==1:
    IPdisplay(IPAudio(waveform, rate=sample_rate))
    return
  num_channels, num_frames = waveform.shape
  if num_channels <= 1:
    IPdisplay(IPAudio(waveform[0], rate=sample_rate))
  elif num_channels == 2:
    IPdisplay(IPAudio((waveform[0], waveform[1]), rate=sample_rate))
  else:
    raise ValueError("Waveform with more than 2 channels are not supported.")

# set the g2p module for the tokenizer
tokenizer.set_g2p(model.fastspeech2.g2p)
# you can run in half mode on gpu.
model = model.cuda().half()
sentences = [
        "Advanced text to speech models such as Fast Speech can synthesize speech significantly faster than previous auto regressive models with comparable quality. The training of Fast Speech model relies on an auto regressive teacher model for duration prediction and knowledge distillation, which can ease the one to many mapping problem in T T S. However, Fast Speech has several disadvantages, 1, the teacher student distillation pipeline is complicated, 2, the duration extracted from the teacher model is not accurate enough, and the target mel spectrograms distilled from teacher model suffer from information loss due to data simplification, both of which limit the voice quality. ",
        "Printing, in the only sense with which we are at present concerned, differs from most if not from all the arts and crafts represented in the Exhibition "
        "in being comparatively modern. ",
        "For although the Chinese took impressions from wood blocks engraved in relief for centuries before the woodcutters of the Netherlands, by a similar process "
        "produced the block books, which were the immediate predecessors of the true printed book, "
        "the invention of movable metal letters in the middle of the fifteenth century may justly be considered as the invention of the art of printing. ",
        "And it is worth mention in passing that, as an example of fine typography, "
        "the earliest book printed with movable types, the Gutenberg, or \"forty-two line Bible\" of about 1455, "
        "has never been surpassed. ",
        "Printing, then, for our purpose, may be considered as the art of making books by means of movable types. "
        "Now, as all books not primarily intended as picture-books consist principally of types composed to form letterpress,",
       ]
batch = tokenizer(sentences, return_tensors="pt", padding=True)

model.eval()
with torch.no_grad():
  out = model(use_postnet=False, **batch)
wav =out[-2]
for line, phone, w in zip(sentences, tokenizer.batch_decode(batch['input_ids']), wav):
  print ("txt:", line)
  print ("phoneme:", phone)
  play_audio(w.type(torch.FloatTensor), model.config.sampling_rate)

```


##Github Code Repo
Current code for this model can be found [here](https://github.com/ontocord/fastspeech2_hf)


This is a work in progress (WIP) port of the model and code from\
[this repo] (https://github.com/ming024/FastSpeech2).


The datasets on which this model was trained:


- LJSpeech: a single-speaker English dataset consists of 13100 short audio clips of a female speaker reading passages from 7 non-fiction books, approximately 24 hours in total.
- LibriTTS: a multi-speaker English dataset containing 585 hours of speech by 2456 speakers.


model name: fastspeech2-en


model author: ontocord


tags: pytorch, fastspeech2, en, dataset:LJSpeech, dataset:LibriTTS, arxiv:2006.04558, transformers, audio, TTS, license:apache-2.0


tags:


- generated_from_trainer
metrics:
- precision
- recall
- f1
- accuracy
model-index:
- name: spanberta-base-cased-finetuned2-nerconcat
results: []


<!-- This model card has been generated automatically according to the information the Trainer had access to. You
should probably proofread and complete it, then remove this comment. -->


# spanberta-base-cased-finetuned2-nerconcat


This model is a fine-tuned version of [skimai/spanberta-base-cased](https://huggingface.co/skimai/spanberta-base-cased) on the None dataset.
It achieves the following results on the evaluation set:


- Loss: 0.1300
- Precision: 0.8409
- Recall: 0.8747
- F1: 0.8575
- Accuracy: 0.9790


## Model description


More information needed


## Intended uses & limitations


## Training and evaluation data


## Training procedure


### Training hyperparameters


The following hyperparameters were used during training:


- learning_rate: 3e-05
- train_batch_size: 2
- eval_batch_size: 2
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- num_epochs: 4


### Training results


| Training Loss | Epoch | Step  | Validation Loss | Precision | Recall | F1     | Accuracy |
|:-------------:|:-----:|:-----:|:---------------:|:---------:|:------:|:------:|:--------:|
| 0.0963        | 1.0   | 11183 | 0.1149          | 0.8048    | 0.8569 | 0.8300 | 0.9735   |
| 0.0623        | 2.0   | 22366 | 0.1123          | 0.8195    | 0.8643 | 0.8413 | 0.9758   |
| 0.0339        | 3.0   | 33549 | 0.1167          | 0.8313    | 0.8752 | 0.8527 | 0.9780   |
| 0.0172        | 4.0   | 44732 | 0.1300          | 0.8409    | 0.8747 | 0.8575 | 0.9790   |


### Framework versions


- Transformers 4.13.0
- Pytorch 1.10.0+cu111
- Datasets 1.16.1
- Tokenizers 0.10.3


model name: spanberta-base-cased-finetuned2-nerconcat


model author: StivenLancheros


task: token-classification


tags: pytorch, tensorboard, roberta, token-classification, transformers, generated_from_trainer, model-index, autonlp_compatible, infinity_compatible


license: mit
tags:


- generated_from_trainer
datasets:
- conll2002
metrics:
- precision
- recall
- f1
- accuracy
model-index:
- name: xlm-roberta-base-finetuned-ner-false
results:
  - task:
name: Token Classification
type: token-classification
dataset:
name: conll2002
type: conll2002
args: es
metrics:
    - name: Precision
type: precision
value: 0.8630790190735694
    - name: Recall
type: recall
value: 0.8733915441176471
    - name: F1
type: f1
value: 0.868204659661946
    - name: Accuracy
type: accuracy
value: 0.9799142149915916


# xlm-roberta-base-finetuned-ner-false


This model is a fine-tuned version of [xlm-roberta-base](https://huggingface.co/xlm-roberta-base) on the conll2002 dataset.
It achieves the following results on the evaluation set:


- Loss: 0.1358
- Precision: 0.8631
- Recall: 0.8734
- F1: 0.8682
- Accuracy: 0.9799


## Model description


More information needed


## Intended uses & limitations


## Training and evaluation data


## Training procedure


### Training hyperparameters


### Training results


| Training Loss | Epoch | Step  | Validation Loss | Precision | Recall | F1     | Accuracy |
|:-------------:|:-----:|:-----:|:---------------:|:---------:|:------:|:------:|:--------:|
| 0.086         | 1.0   | 4162  | 0.1333          | 0.8411    | 0.8318 | 0.8364 | 0.9750   |
| 0.0617        | 2.0   | 8324  | 0.1147          | 0.8482    | 0.8631 | 0.8556 | 0.9773   |
| 0.0384        | 3.0   | 12486 | 0.1144          | 0.8643    | 0.8736 | 0.8689 | 0.9796   |
| 0.023         | 4.0   | 16648 | 0.1358          | 0.8631    | 0.8734 | 0.8682 | 0.9799   |


### Framework versions


- Transformers 4.12.5
- Pytorch 1.10.0+cu111
- Datasets 1.16.1
- Tokenizers 0.10.3


model name: xlm-roberta-base-finetuned-ner-false


model author: StivenLancheros


task: token-classification


tags: pytorch, tensorboard, xlm-roberta, token-classification, dataset:conll2002, transformers, license:mit, generated_from_trainer, model-index, autonlp_compatible


license: apache-2.0
tags:


- generated_from_trainer
datasets:
- conll2003
metrics:
- precision
- recall
- f1
- accuracy
model-index:
- name: bert-base-multilingual-cased-finetuned-ner
results:
  - task:
name: Token Classification
type: token-classification
dataset:
name: conll2003
type: conll2003
args: conll2003
metrics:
    - name: Precision
type: precision
value: 0.9489057950596412
    - name: Recall
type: recall
value: 0.9541033147606006
    - name: F1
type: f1
value: 0.9514974571482389
    - name: Accuracy
type: accuracy
value: 0.9879831588795976


<!-- This model card has been generated automatically according to the information the Trainer had access to. You
should probably proofread and complete it, then remove this comment. -->


# bert-base-multilingual-cased-finetuned-ner


This model is a fine-tuned version of [bert-base-multilingual-cased](https://huggingface.co/bert-base-multilingual-cased) on the conll2003 dataset.
It achieves the following results on the evaluation set:


- Loss: 0.0585
- Precision: 0.9489
- Recall: 0.9541
- F1: 0.9515
- Accuracy: 0.9880


## Model description


More information needed


## Intended uses & limitations


## Training and evaluation data


## Training procedure


### Training hyperparameters


The following hyperparameters were used during training:


- learning_rate: 3e-05
- train_batch_size: 16
- eval_batch_size: 16
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- num_epochs: 4


### Training results


| Training Loss | Epoch | Step | Validation Loss | Precision | Recall | F1     | Accuracy |
|:-------------:|:-----:|:----:|:---------------:|:---------:|:------:|:------:|:--------:|
| 0.1739        | 1.0   | 878  | 0.0741          | 0.9246    | 0.9181 | 0.9213 | 0.9823   |
| 0.045         | 2.0   | 1756 | 0.0586          | 0.9469    | 0.9476 | 0.9472 | 0.9870   |
| 0.0213        | 3.0   | 2634 | 0.0583          | 0.9503    | 0.9510 | 0.9506 | 0.9877   |
| 0.0113        | 4.0   | 3512 | 0.0585          | 0.9489    | 0.9541 | 0.9515 | 0.9880   |


### Framework versions


- Transformers 4.12.3
- Pytorch 1.9.0+cu111
- Datasets 1.15.1
- Tokenizers 0.10.3


model name: bert-base-multilingual-cased-finetuned-ner


model author: StivenLancheros


task: token-classification


tags: pytorch, tensorboard, bert, token-classification, dataset:conll2003, transformers, license:apache-2.0, generated_from_trainer, model-index, autonlp_compatible, infinity_compatible


tags:


- generated_from_trainer
datasets:
- conll2003
metrics:
- precision
- recall
- f1
- accuracy
model-index:
- name: spanberta-base-cased-ner-conll02-finetuned-ner
results:
  - task:
name: Token Classification
type: token-classification
dataset:
name: conll2003
type: conll2003
args: conll2003
metrics:
    - name: Precision
type: precision
value: 0.911773494695951
    - name: Recall
type: recall
value: 0.9149861308943699
    - name: F1
type: f1
value: 0.9133769878391019
    - name: Accuracy
type: accuracy
value: 0.9803183888541573


# spanberta-base-cased-ner-conll02-finetuned-ner


This model is a fine-tuned version of [skimai/spanberta-base-cased-ner-conll02](https://huggingface.co/skimai/spanberta-base-cased-ner-conll02) on the conll2003 dataset.
It achieves the following results on the evaluation set:


- Loss: 0.0824
- Precision: 0.9118
- Recall: 0.9150
- F1: 0.9134
- Accuracy: 0.9803


## Model description


More information needed


## Intended uses & limitations


## Training and evaluation data


## Training procedure


### Training hyperparameters


- learning_rate: 2e-05
- train_batch_size: 16
- eval_batch_size: 16
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- num_epochs: 3


### Training results


| Training Loss | Epoch | Step | Validation Loss | Precision | Recall | F1     | Accuracy |
|:-------------:|:-----:|:----:|:---------------:|:---------:|:------:|:------:|:--------:|
| 0.2641        | 1.0   | 878  | 0.0923          | 0.8818    | 0.8802 | 0.8810 | 0.9739   |
| 0.0648        | 2.0   | 1756 | 0.0817          | 0.9033    | 0.9044 | 0.9038 | 0.9785   |
| 0.0314        | 3.0   | 2634 | 0.0824          | 0.9118    | 0.9150 | 0.9134 | 0.9803   |


### Framework versions


model name: spanberta-base-cased-ner-conll02-finetuned-ner


model author: StivenLancheros


task: token-classification


tags: pytorch, tensorboard, roberta, token-classification, dataset:conll2003, transformers, generated_from_trainer, model-index, autonlp_compatible, infinity_compatible


license: apache-2.0
tags:


- generated_from_trainer
datasets:
- conll2003
metrics:
- precision
- recall
- f1
- accuracy
model-index:
- name: bert-large-cased-finetuned-ner
results:
  - task:
name: Token Classification
type: token-classification
dataset:
name: conll2003
type: conll2003
args: conll2003
metrics:
    - name: Precision
type: precision
value: 0.9517124206384691
    - name: Recall
type: recall
value: 0.9548717028530415
    - name: F1
type: f1
value: 0.9532894442205204
    - name: Accuracy
type: accuracy
value: 0.9872696768116795


<!-- This model card has been generated automatically according to the information the Trainer had access to. You
should probably proofread and complete it, then remove this comment. -->


# bert-large-cased-finetuned-ner


This model is a fine-tuned version of [bert-large-cased](https://huggingface.co/bert-large-cased) on the conll2003 dataset.
It achieves the following results on the evaluation set:


- Loss: 0.0789
- Precision: 0.9517
- Recall: 0.9549
- F1: 0.9533
- Accuracy: 0.9873


## Model description


More information needed


## Intended uses & limitations


## Training and evaluation data


## Training procedure


### Training hyperparameters


The following hyperparameters were used during training:


- learning_rate: 3e-05
- train_batch_size: 5
- eval_batch_size: 5
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- num_epochs: 4


### Training results


| Training Loss | Epoch | Step  | Validation Loss | Precision | Recall | F1     | Accuracy |
|:-------------:|:-----:|:-----:|:---------------:|:---------:|:------:|:------:|:--------:|
| 0.1009        | 1.0   | 2809  | 0.0804          | 0.9299    | 0.9272 | 0.9286 | 0.9820   |
| 0.0443        | 2.0   | 5618  | 0.0653          | 0.9466    | 0.9491 | 0.9479 | 0.9862   |
| 0.0197        | 3.0   | 8427  | 0.0770          | 0.9497    | 0.9460 | 0.9478 | 0.9861   |
| 0.0126        | 4.0   | 11236 | 0.0789          | 0.9517    | 0.9549 | 0.9533 | 0.9873   |


### Framework versions


- Transformers 4.12.5
- Pytorch 1.10.0+cu111
- Datasets 1.15.1
- Tokenizers 0.10.3


model name: bert-large-cased-finetuned-ner


model author: StivenLancheros


task: token-classification


tags: pytorch, tensorboard, bert, token-classification, dataset:conll2003, transformers, license:apache-2.0, generated_from_trainer, model-index, autonlp_compatible, infinity_compatible


license: apache-2.0
tags:


- generated_from_trainer
metrics:
- precision
- recall
- f1
- accuracy
model-index:
- name: bert-base-multilingual-cased-finetuned-ner-4
results: []


# bert-base-multilingual-cased-finetuned-ner-4


#This model is part of a test for creating multilingual BioMedical NER systems. Not intended for proffesional use now.


This model is a fine-tuned version of [bert-base-multilingual-cased](https://huggingface.co/bert-base-multilingual-cased) on the None dataset.
It achieves the following results on the evaluation set:


- Loss: 0.1027
- Precision: 0.9830
- Recall: 0.9832
- F1: 0.9831
- Accuracy: 0.9799


## Model description


More information needed


## Intended uses & limitations


## Training and evaluation data


## Training procedure


### Training hyperparameters


- learning_rate: 3e-05
- train_batch_size: 8
- eval_batch_size: 8
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- num_epochs: 4


### Training results


| Training Loss | Epoch | Step  | Validation Loss | Precision | Recall | F1     | Accuracy |
|:-------------:|:-----:|:-----:|:---------------:|:---------:|:------:|:------:|:--------:|
| 0.0658        | 1.0   | 6128  | 0.0751          | 0.9795    | 0.9795 | 0.9795 | 0.9758   |
| 0.0406        | 2.0   | 12256 | 0.0753          | 0.9827    | 0.9815 | 0.9821 | 0.9786   |
| 0.0182        | 3.0   | 18384 | 0.0934          | 0.9834    | 0.9825 | 0.9829 | 0.9796   |
| 0.011         | 4.0   | 24512 | 0.1027          | 0.9830    | 0.9832 | 0.9831 | 0.9799   |


### Framework versions


- Transformers 4.16.2
- Pytorch 1.10.0+cu111
- Datasets 1.18.3
- Tokenizers 0.11.0


model name: mBERT-base-Biomedical-NER


model author: StivenLancheros


task: token-classification


tags: pytorch, tensorboard, bert, token-classification, transformers, license:apache-2.0, generated_from_trainer, model-index, autonlp_compatible, infinity_compatible


tags:


- generated_from_trainer
metrics:
- precision
- recall
- f1
- accuracy
model-index:
- name: biobert-base-cased-v1.2-finetuned-ner-2
results: []


<!-- This model card has been generated automatically according to the information the Trainer had access to. You
should probably proofread and complete it, then remove this comment. -->


# biobert-base-cased-v1.2-finetuned-ner-2


This model is a fine-tuned version of [dmis-lab/biobert-base-cased-v1.2](https://huggingface.co/dmis-lab/biobert-base-cased-v1.2) on the None dataset.
It achieves the following results on the evaluation set:


- Loss: 0.1357
- Precision: 0.8448
- Recall: 0.8368
- F1: 0.8408
- Accuracy: 0.9821


## Model description


More information needed


## Intended uses & limitations


## Training and evaluation data


## Training procedure


### Training hyperparameters


The following hyperparameters were used during training:


- learning_rate: 3e-05
- train_batch_size: 8
- eval_batch_size: 8
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- num_epochs: 8


### Training results


| Training Loss | Epoch | Step  | Validation Loss | Precision | Recall | F1     | Accuracy |
|:-------------:|:-----:|:-----:|:---------------:|:---------:|:------:|:------:|:--------:|
| 0.0571        | 1.0   | 6128  | 0.0733          | 0.8038    | 0.7923 | 0.7980 | 0.9776   |
| 0.0382        | 2.0   | 12256 | 0.0822          | 0.8212    | 0.8053 | 0.8132 | 0.9791   |
| 0.0184        | 3.0   | 18384 | 0.0885          | 0.8227    | 0.8374 | 0.8299 | 0.9805   |
| 0.0111        | 4.0   | 24512 | 0.0976          | 0.8433    | 0.8225 | 0.8328 | 0.9815   |
| 0.0065        | 5.0   | 30640 | 0.1049          | 0.8334    | 0.8300 | 0.8317 | 0.9810   |
| 0.0031        | 6.0   | 36768 | 0.1191          | 0.8377    | 0.8309 | 0.8343 | 0.9813   |
| 0.0022        | 7.0   | 42896 | 0.1275          | 0.8306    | 0.8453 | 0.8379 | 0.9817   |
| 0.0007        | 8.0   | 49024 | 0.1357          | 0.8448    | 0.8368 | 0.8408 | 0.9821   |


### Framework versions


- Transformers 4.16.2
- Pytorch 1.10.0+cu111
- Datasets 1.18.2
- Tokenizers 0.11.0


model name: biobert-base-cased-v1.2-finetuned-ner-2


model author: StivenLancheros


task: token-classification


tags: pytorch, tensorboard, bert, token-classification, transformers, generated_from_trainer, model-index, autonlp_compatible, infinity_compatible


license: apache-2.0
tags:


- generated_from_trainer
datasets:
- conll2002
- conll2003
metrics:
- precision
- recall
- f1
- accuracy
model-index:
- name: mBERT-base-cased-NER-CONLL
results:
  - task:
name: Token Classification
type: token-classification
dataset:
name: conll2002
type: conll2002
args: es
metrics:
    - name: Precision
type: precision
value: 0.8621083924079579
    - name: Recall
type: recall
value: 0.8662683823529411
    - name: F1
type: f1
value: 0.8641833810888252
    - name: Accuracy
type: accuracy
value: 0.9790639230580277


# mBERT-base-cased-NER-CONLL (EN-ES)


This model is a fine-tuned version of [bert-base-multilingual-cased ](https://huggingface.co/bert-base-multilingual-cased) on the conll2003 and conll2002 datasets. Training was performed separately.
It achieves the following results on the evaluation set:


- Loss: 0.0585
- Precision: 0.9489
- Recall: 0.9541
- F1: 0.9515
- Accuracy: 0.9880


- Loss: 0.1435
- Precision: 0.8621
- Recall: 0.8663
- F1: 0.8642
- Accuracy: 0.9791


## Model description


IOB tagging Scheme. PER/LOC/MISC/ORG tags


## Intended uses & limitations


More information needed


## Training and evaluation data


Conll2002/2003 (ES-EN)


## Training procedure


### Training hyperparameters


- learning_rate: 3e-05
- train_batch_size: 2
- eval_batch_size: 2
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- num_epochs: 4


### Training results


| Training Loss | Epoch | Step | Validation Loss | Precision | Recall | F1     | Accuracy |
|:-------------:|:-----:|:----:|:---------------:|:---------:|:------:|:------:|:--------:|
| 0.1739        | 1.0   | 878  | 0.0741          | 0.9246    | 0.9181 | 0.9213 | 0.9823   |
| 0.045         | 2.0   | 1756 | 0.0586          | 0.9469    | 0.9476 | 0.9472 | 0.9870   |
| 0.0213        | 3.0   | 2634 | 0.0583          | 0.9503    | 0.9510 | 0.9506 | 0.9877   |
| 0.0113        | 4.0   | 3512 | 0.0585          | 0.9489    | 0.9541 | 0.9515 | 0.9880   |


| Training Loss | Epoch | Step  | Validation Loss | Precision | Recall | F1     | Accuracy |
|:-------------:|:-----:|:-----:|:---------------:|:---------:|:------:|:------:|:--------:|
| 0.0739        | 1.0   | 4162  | 0.1322          | 0.8430    | 0.8267 | 0.8348 | 0.9741   |
| 0.0454        | 2.0   | 8324  | 0.1158          | 0.8664    | 0.8614 | 0.8639 | 0.9782   |
| 0.031         | 3.0   | 12486 | 0.1243          | 0.8521    | 0.8660 | 0.8590 | 0.9783   |
| 0.0136        | 4.0   | 16648 | 0.1435          | 0.8621    | 0.8663 | 0.8642 | 0.9791   |


### Framework versions


- Transformers 4.12.3
- Pytorch 1.10.0+cu111
- Datasets 1.15.1
- Tokenizers 0.10.3


model name: mBERT-base-cased-NER-CONLL


model author: StivenLancheros


task: token-classification


tags: pytorch, tensorboard, bert, token-classification, dataset:conll2002, dataset:conll2003, transformers, license:apache-2.0, generated_from_trainer, model-index, autonlp_compatible, infinity_compatible


license: apache-2.0
tags:


- generated_from_trainer
datasets:
- conll2003
metrics:
- precision
- recall
- f1
- accuracy
model-index:
- name: roberta-base-bne-finetuned-ner
results:
  - task:
name: Token Classification
type: token-classification
dataset:
name: conll2003
type: conll2003
args: conll2003
metrics:
    - name: Precision
type: precision
value: 0.9237957261861645
    - name: Recall
type: recall
value: 0.9351077870655521
    - name: F1
type: f1
value: 0.9294173377546188
    - name: Accuracy
type: accuracy
value: 0.9847536857245595


<!-- This model card has been generated automatically according to the information the Trainer had access to. You
should probably proofread and complete it, then remove this comment. -->


# roberta-base-bne-finetuned-ner


This model is a fine-tuned version of [PlanTL-GOB-ES/roberta-base-bne](https://huggingface.co/PlanTL-GOB-ES/roberta-base-bne) on the conll2003 dataset.
It achieves the following results on the evaluation set:


- Loss: 0.0659
- Precision: 0.9238
- Recall: 0.9351
- F1: 0.9294
- Accuracy: 0.9848


## Model description


More information needed


## Intended uses & limitations


## Training and evaluation data


## Training procedure


### Training hyperparameters


The following hyperparameters were used during training:


- learning_rate: 3e-05
- train_batch_size: 16
- eval_batch_size: 16
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- num_epochs: 4


### Training results


| Training Loss | Epoch | Step | Validation Loss | Precision | Recall | F1     | Accuracy |
|:-------------:|:-----:|:----:|:---------------:|:---------:|:------:|:------:|:--------:|
| 0.1931        | 1.0   | 878  | 0.0800          | 0.8892    | 0.8853 | 0.8872 | 0.9770   |
| 0.0409        | 2.0   | 1756 | 0.0655          | 0.9178    | 0.9238 | 0.9208 | 0.9828   |
| 0.0138        | 3.0   | 2634 | 0.0663          | 0.9207    | 0.9276 | 0.9241 | 0.9839   |
| 0.0051        | 4.0   | 3512 | 0.0659          | 0.9238    | 0.9351 | 0.9294 | 0.9848   |


### Framework versions


- Transformers 4.12.3
- Pytorch 1.9.0+cu111
- Datasets 1.15.1
- Tokenizers 0.10.3


model name: roberta-base-bne-finetuned-ner


model author: StivenLancheros


task: token-classification


tags: pytorch, tensorboard, roberta, token-classification, dataset:conll2003, transformers, license:apache-2.0, generated_from_trainer, model-index, autonlp_compatible, infinity_compatible


tags:


- generated_from_trainer
metrics:
- precision
- recall
- f1
- accuracy
model-index:
- name: biobert-base-cased-v1.2-finetuned-ner-3
results: []


# biobert-base-cased-v1.2-finetuned-ner-3


This model is a fine-tuned version of [dmis-lab/biobert-base-cased-v1.2](https://huggingface.co/dmis-lab/biobert-base-cased-v1.2) on the None dataset.
It achieves the following results on the evaluation set:


- Loss: 0.0949
- Precision: 0.8619
- Recall: 0.8600
- F1: 0.8609
- Accuracy: 0.9822


## Model description


More information needed


## Intended uses & limitations


## Training and evaluation data


## Training procedure


### Training hyperparameters


- learning_rate: 3e-05
- train_batch_size: 8
- eval_batch_size: 8
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- num_epochs: 4


### Training results


| Training Loss | Epoch | Step  | Validation Loss | Precision | Recall | F1     | Accuracy |
|:-------------:|:-----:|:-----:|:---------------:|:---------:|:------:|:------:|:--------:|
| 0.0562        | 1.0   | 6128  | 0.0693          | 0.8507    | 0.8034 | 0.8264 | 0.9790   |
| 0.0307        | 2.0   | 12256 | 0.0739          | 0.8527    | 0.8468 | 0.8497 | 0.9810   |
| 0.0142        | 3.0   | 18384 | 0.0895          | 0.8449    | 0.8549 | 0.8499 | 0.9804   |
| 0.0073        | 4.0   | 24512 | 0.0949          | 0.8619    | 0.8600 | 0.8609 | 0.9822   |


### Framework versions


- Transformers 4.16.2
- Pytorch 1.10.0+cu111
- Datasets 1.18.2
- Tokenizers 0.11.0


model name: biobert-base-cased-v1.2-finetuned-ner-3


model author: StivenLancheros


task: token-classification


tags: pytorch, tensorboard, bert, token-classification, transformers, generated_from_trainer, model-index, autonlp_compatible, infinity_compatible


license: mit
tags:


- generated_from_trainer
metrics:
- precision
- recall
- f1
- accuracy
model-index:
- name: xlm-roberta-base-finetuned2-nerconcat-base
results: []


<!-- This model card has been generated automatically according to the information the Trainer had access to. You
should probably proofread and complete it, then remove this comment. -->


# xlm-roberta-base-finetuned2-nerconcat-base


This model is a fine-tuned version of [xlm-roberta-base](https://huggingface.co/xlm-roberta-base) on the None dataset.
It achieves the following results on the evaluation set:


- Loss: 0.1019
- Precision: 0.9079
- Recall: 0.9167
- F1: 0.9123
- Accuracy: 0.9845


## Model description


More information needed


## Intended uses & limitations


## Training and evaluation data


## Training procedure


### Training hyperparameters


The following hyperparameters were used during training:


- learning_rate: 3e-05
- train_batch_size: 2
- eval_batch_size: 2
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- num_epochs: 4


### Training results


| Training Loss | Epoch | Step  | Validation Loss | Precision | Recall | F1     | Accuracy |
|:-------------:|:-----:|:-----:|:---------------:|:---------:|:------:|:------:|:--------:|
| 0.0776        | 1.0   | 11183 | 0.0831          | 0.8853    | 0.8777 | 0.8815 | 0.9796   |
| 0.0538        | 2.0   | 22366 | 0.0956          | 0.8937    | 0.9013 | 0.8975 | 0.9821   |
| 0.0355        | 3.0   | 33549 | 0.1021          | 0.8997    | 0.9084 | 0.9040 | 0.9832   |
| 0.0204        | 4.0   | 44732 | 0.1019          | 0.9079    | 0.9167 | 0.9123 | 0.9845   |


### Framework versions


- Transformers 4.15.0
- Pytorch 1.10.0+cu111
- Datasets 1.17.0
- Tokenizers 0.10.3


model name: xlm-roberta-base-finetuned2-nerconcat-base


model author: StivenLancheros


task: token-classification


tags: pytorch, tensorboard, xlm-roberta, token-classification, transformers, license:mit, generated_from_trainer, model-index, autonlp_compatible


license: apache-2.0
tags:


- generated_from_trainer
metrics:
- precision
- recall
- f1
- accuracy
model-index:
- name: bert-base-multilingual-cased-finetuned2-nerconcat
results: []


# bert-base-multilingual-cased-finetuned2-nerconcat


This model is a fine-tuned version of [bert-base-multilingual-cased](https://huggingface.co/bert-base-multilingual-cased) on the None dataset.
It achieves the following results on the evaluation set:


- Loss: 0.0752
- Precision: 0.9182
- Recall: 0.9203
- F1: 0.9193
- Accuracy: 0.9857


## Model description


More information needed


## Intended uses & limitations


## Training and evaluation data


## Training procedure


### Training hyperparameters


- learning_rate: 3e-05
- train_batch_size: 8
- eval_batch_size: 8
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- num_epochs: 4


### Training results


| Training Loss | Epoch | Step  | Validation Loss | Precision | Recall | F1     | Accuracy |
|:-------------:|:-----:|:-----:|:---------------:|:---------:|:------:|:------:|:--------:|
| 0.0605        | 1.0   | 2796  | 0.0669          | 0.8904    | 0.8992 | 0.8948 | 0.9813   |
| 0.0339        | 2.0   | 5592  | 0.0616          | 0.9057    | 0.9181 | 0.9119 | 0.9852   |
| 0.0208        | 3.0   | 8388  | 0.0667          | 0.9089    | 0.9162 | 0.9125 | 0.9851   |
| 0.009         | 4.0   | 11184 | 0.0752          | 0.9182    | 0.9203 | 0.9193 | 0.9857   |


### Framework versions


- Transformers 4.13.0
- Pytorch 1.10.0+cu111
- Datasets 1.16.1
- Tokenizers 0.10.3


model name: bert-base-multilingual-cased-finetuned2-nerconcat


model author: StivenLancheros


task: token-classification


tags: pytorch, tensorboard, bert, token-classification, transformers, license:apache-2.0, generated_from_trainer, model-index, autonlp_compatible, infinity_compatible


tags:


- generated_from_trainer
datasets:
- conll2002
metrics:
- precision
- recall
- f1
- accuracy
model-index:
- name: bert-base-spanish-wwm-cased-finetuned-ner-false
results:
  - task:
name: Token Classification
type: token-classification
dataset:
name: conll2002
type: conll2002
args: es
metrics:
    - name: Precision
type: precision
value: 0.8527941844616084
    - name: Recall
type: recall
value: 0.8625919117647058
    - name: F1
type: f1
value: 0.8576650673977612
    - name: Accuracy
type: accuracy
value: 0.9780246773614496


<!-- This model card has been generated automatically according to the information the Trainer had access to. You
should probably proofread and complete it, then remove this comment. -->


# bert-base-spanish-wwm-cased-finetuned-ner-false


This model is a fine-tuned version of [dccuchile/bert-base-spanish-wwm-cased](https://huggingface.co/dccuchile/bert-base-spanish-wwm-cased) on the conll2002 dataset.
It achieves the following results on the evaluation set:


- Loss: 0.1154
- Precision: 0.8528
- Recall: 0.8626
- F1: 0.8577
- Accuracy: 0.9780


## Model description


More information needed


## Intended uses & limitations


## Training and evaluation data


## Training procedure


### Training hyperparameters


The following hyperparameters were used during training:


- learning_rate: 3e-05
- train_batch_size: 10
- eval_batch_size: 10
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- num_epochs: 4


### Training results


| Training Loss | Epoch | Step | Validation Loss | Precision | Recall | F1     | Accuracy |
|:-------------:|:-----:|:----:|:---------------:|:---------:|:------:|:------:|:--------:|
| 0.1072        | 1.0   | 833  | 0.0905          | 0.8432    | 0.8451 | 0.8442 | 0.9779   |
| 0.0347        | 2.0   | 1666 | 0.0934          | 0.8592    | 0.8612 | 0.8602 | 0.9782   |
| 0.0218        | 3.0   | 2499 | 0.1078          | 0.8537    | 0.8568 | 0.8553 | 0.9776   |
| 0.0106        | 4.0   | 3332 | 0.1154          | 0.8528    | 0.8626 | 0.8577 | 0.9780   |


### Framework versions


- Transformers 4.12.5
- Pytorch 1.10.0+cu111
- Datasets 1.15.1
- Tokenizers 0.10.3


model name: bert-base-spanish-wwm-cased-finetuned-ner-false


model author: StivenLancheros


task: token-classification


tags: pytorch, tensorboard, bert, token-classification, dataset:conll2002, transformers, generated_from_trainer, model-index, autonlp_compatible, infinity_compatible


license: mit
tags:


- generated_from_trainer
datasets:
- conll2003
metrics:
- precision
- recall
- f1
- accuracy
model-index:
- name: xlm-roberta-base-finetuned-ner-false-finetuned-ner-2002
results:
  - task:
name: Token Classification
type: token-classification
dataset:
name: conll2003
type: conll2003
args: conll2003
metrics:
    - name: Precision
type: precision
value: 0.941186271242919
    - name: Recall
type: recall
value: 0.9506900033658701
    - name: F1
type: f1
value: 0.945914266577361
    - name: Accuracy
type: accuracy
value: 0.9904209337642615


# xlm-roberta-base-finetuned-ner-false-finetuned-ner-2002


This model is a fine-tuned version of [StivenLancheros/xlm-roberta-base-finetuned-ner-false](https://huggingface.co/StivenLancheros/xlm-roberta-base-finetuned-ner-false) on the conll2003 dataset.
It achieves the following results on the evaluation set:


- Loss: 0.0725
- Precision: 0.9412
- Recall: 0.9507
- F1: 0.9459
- Accuracy: 0.9904


## Model description


More information needed


## Intended uses & limitations


## Training and evaluation data


## Training procedure


### Training hyperparameters


- learning_rate: 3e-05
- train_batch_size: 2
- eval_batch_size: 2
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- num_epochs: 4


### Training results


| Training Loss | Epoch | Step  | Validation Loss | Precision | Recall | F1     | Accuracy |
|:-------------:|:-----:|:-----:|:---------------:|:---------:|:------:|:------:|:--------:|
| 0.086         | 1.0   | 7021  | 0.0709          | 0.9221    | 0.9261 | 0.9241 | 0.9872   |
| 0.0352        | 2.0   | 14042 | 0.0871          | 0.9243    | 0.9354 | 0.9298 | 0.9879   |
| 0.0203        | 3.0   | 21063 | 0.0747          | 0.9398    | 0.9490 | 0.9444 | 0.9901   |
| 0.0184        | 4.0   | 28084 | 0.0725          | 0.9412    | 0.9507 | 0.9459 | 0.9904   |


### Framework versions


- Transformers 4.12.5
- Pytorch 1.10.0+cu111
- Datasets 1.16.1
- Tokenizers 0.10.3


model name: xlm-roberta-base-finetuned-ner-false-finetuned-ner-2002-1


model author: StivenLancheros


task: token-classification


tags: pytorch, tensorboard, xlm-roberta, token-classification, dataset:conll2003, transformers, license:mit, generated_from_trainer, model-index, autonlp_compatible


license: apache-2.0
tags:


- generated_from_trainer
metrics:
- precision
- recall
- f1
- accuracy
model-index:
- name: roberta-base-biomedical-clinical-es-finetuned-ner-3
results: []


<!-- This model card has been generated automatically according to the information the Trainer had access to. You
should probably proofread and complete it, then remove this comment. -->


# roberta-base-biomedical-clinical-es-finetuned-ner-3


#This is a Test for a Multilingual version of Biomedical NER using English data in Spanish pretrained models. Not indented to be used.


This model is a fine-tuned version of [PlanTL-GOB-ES/roberta-base-biomedical-clinical-es](https://huggingface.co/PlanTL-GOB-ES/roberta-base-biomedical-clinical-es) on the None dataset.
It achieves the following results on the evaluation set:


- Loss: 0.1019
- Precision: 0.9809
- Recall: 0.9808
- F1: 0.9809
- Accuracy: 0.9792


## Model description


More information needed


## Intended uses & limitations


## Training and evaluation data


## Training procedure


### Training hyperparameters


The following hyperparameters were used during training:


- learning_rate: 3e-05
- train_batch_size: 8
- eval_batch_size: 8
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- num_epochs: 4


### Training results


| Training Loss | Epoch | Step  | Validation Loss | Precision | Recall | F1     | Accuracy |
|:-------------:|:-----:|:-----:|:---------------:|:---------:|:------:|:------:|:--------:|
| 0.0693        | 1.0   | 6128  | 0.0801          | 0.9755    | 0.9783 | 0.9769 | 0.9751   |
| 0.0419        | 2.0   | 12256 | 0.0797          | 0.9794    | 0.9804 | 0.9799 | 0.9784   |
| 0.0202        | 3.0   | 18384 | 0.0921          | 0.9802    | 0.9814 | 0.9808 | 0.9791   |
| 0.0126        | 4.0   | 24512 | 0.1019          | 0.9809    | 0.9808 | 0.9809 | 0.9792   |


### Framework versions


- Transformers 4.16.2
- Pytorch 1.10.0+cu111
- Datasets 1.18.3
- Tokenizers 0.11.0


model name: roberta-base-biomedical-clinical-es-finetuned-ner-3


model author: StivenLancheros


task: token-classification


tags: pytorch, tensorboard, roberta, token-classification, transformers, license:apache-2.0, generated_from_trainer, model-index, autonlp_compatible, infinity_compatible


license: apache-2.0
tags:


- generated_from_trainer
datasets:
- conll2002
metrics:
- precision
- recall
- f1
- accuracy
model-index:
- name: roberta-base-bne-finetuned-ner-finetuned2-ner
results:
  - task:
name: Token Classification
type: token-classification
dataset:
name: conll2002
type: conll2002
args: es
metrics:
    - name: Precision
type: precision
value: 0.8697727272727273
    - name: Recall
type: recall
value: 0.8793658088235294
    - name: F1
type: f1
value: 0.8745429616087752
    - name: Accuracy
type: accuracy
value: 0.9808778791829639


# roberta-base-bne-finetuned-ner-finetuned2-ner


This model is a fine-tuned version of [StivenLancheros/roberta-base-bne-finetuned-ner](https://huggingface.co/StivenLancheros/roberta-base-bne-finetuned-ner) on the conll2002 dataset.
It achieves the following results on the evaluation set:


- Loss: 0.1067
- Precision: 0.8698
- Recall: 0.8794
- F1: 0.8745
- Accuracy: 0.9809


## Model description


More information needed


## Intended uses & limitations


## Training and evaluation data


## Training procedure


### Training hyperparameters


- learning_rate: 3e-05
- train_batch_size: 5
- eval_batch_size: 5
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- num_epochs: 4


### Training results


| Training Loss | Epoch | Step | Validation Loss | Precision | Recall | F1     | Accuracy |
|:-------------:|:-----:|:----:|:---------------:|:---------:|:------:|:------:|:--------:|
| 0.0582        | 1.0   | 1665 | 0.0852          | 0.8697    | 0.8759 | 0.8728 | 0.9800   |
| 0.0297        | 2.0   | 3330 | 0.0919          | 0.8841    | 0.8867 | 0.8854 | 0.9817   |
| 0.0121        | 3.0   | 4995 | 0.0950          | 0.8751    | 0.8807 | 0.8779 | 0.9812   |
| 0.0056        | 4.0   | 6660 | 0.1067          | 0.8698    | 0.8794 | 0.8745 | 0.9809   |


### Framework versions


- Transformers 4.12.3
- Pytorch 1.10.0+cu111
- Datasets 1.15.1
- Tokenizers 0.10.3


model name: roberta-base-bne-finetuned-ner-finetuned2-ner


model author: StivenLancheros


task: token-classification


tags: pytorch, tensorboard, roberta, token-classification, dataset:conll2002, transformers, license:apache-2.0, generated_from_trainer, model-index, autonlp_compatible, infinity_compatible


license: apache-2.0
tags:


- generated_from_trainer
metrics:
- precision
- recall
- f1
- accuracy
model-index:
- name: roberta-base-bne-finetuned2-nerconcat
results: []


<!-- This model card has been generated automatically according to the information the Trainer had access to. You
should probably proofread and complete it, then remove this comment. -->


# roberta-base-bne-finetuned2-nerconcat


This model is a fine-tuned version of [PlanTL-GOB-ES/roberta-base-bne](https://huggingface.co/PlanTL-GOB-ES/roberta-base-bne) on the None dataset.
It achieves the following results on the evaluation set:


- Loss: 0.0756
- Precision: 0.9078
- Recall: 0.9130
- F1: 0.9104
- Accuracy: 0.9849


## Model description


More information needed


## Intended uses & limitations


## Training and evaluation data


## Training procedure


### Training hyperparameters


The following hyperparameters were used during training:


- learning_rate: 3e-05
- train_batch_size: 8
- eval_batch_size: 8
- seed: 42
- optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08
- lr_scheduler_type: linear
- num_epochs: 4


### Training results


| Training Loss | Epoch | Step  | Validation Loss | Precision | Recall | F1     | Accuracy |
|:-------------:|:-----:|:-----:|:---------------:|:---------:|:------:|:------:|:--------:|
| 0.0593        | 1.0   | 2796  | 0.0704          | 0.8808    | 0.8923 | 0.8865 | 0.9813   |
| 0.0276        | 2.0   | 5592  | 0.0767          | 0.8943    | 0.9032 | 0.8987 | 0.9829   |
| 0.013         | 3.0   | 8388  | 0.0723          | 0.9044    | 0.9112 | 0.9078 | 0.9845   |
| 0.0053        | 4.0   | 11184 | 0.0756          | 0.9078    | 0.9130 | 0.9104 | 0.9849   |


### Framework versions


- Transformers 4.13.0
- Pytorch 1.10.0+cu111
- Datasets 1.16.1
- Tokenizers 0.10.3


model name: roberta-base-bne-finetuned2-nerconcat


model author: StivenLancheros


task: token-classification


tags: pytorch, tensorboard, roberta, token-classification, transformers, license:apache-2.0, generated_from_trainer, model-index, autonlp_compatible, infinity_compatible


This is fine-tuned model on Bhagvad Gita and creates text based on prompts.
Example of usage:


```
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("epsil/bhagvad_gita")

model = AutoModelForCausalLM.from_pretrained("epsil/bhagvad_gita")

```


Input


```
from transformers import pipeline

pipeline = pipeline('text-generation',model=model, tokenizer=tokenizer)

result = samples('Krishna show me the right path')[0]['generated_text']
print(result)

```


Output


```
Krishna show me the right path, and I also to remember the lessons, and to remember them right.

Sama! in His Day, and by Thy own Eternal Grace.

A man like that who shall come to us

```


> Created by [Saurabh Mishra](https://www.linkedin.com/in/saurabh-mishra-12b5a1216/)


> Made with ♥ in India


model name: bhagvad_gita


model author: epsil


task: text-generation


tags: pytorch, gpt2, text-generation, transformers


pretrained convbert_medium-small with PubMed text.


model name: bio-convbert-medium-samll


model author: ray1379


tags:


language: ISO 639-1 code for your language, or `multilingual`
thumbnail: url to a thumbnail used in social sharing
tags:


- array
- of
- tags
datasets:
- array of dataset identifiers
metrics:
- array of metric identifiers
widget:
- text: "question: which description describes the word \" java \" best in the following\
\ context? descriptions: [  \" A drink consisting of an infusion of ground coffee\
\ beans \" ,  \" a platform-independent programming lanugage \" ,  or \" an island\
\ in Indonesia to the south of Borneo \" ]  context: I like to drink ' java '\
\ in the morning ."


# T5-large for Word Sense Disambiguation


This is the checkpoint for T5-large after being trained on the [SemCor 3.0 dataset](http://lcl.uniroma1.it/wsdeval/).


Additional information about this model:


* [The t5-large model page](https://huggingface.co/t5-large)
* [Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer](https://arxiv.org/pdf/1910.10683.pdf)
* [Official implementation by Google](https://github.com/google-research/text-to-text-transfer-transformer)


The model can be loaded to perform a few-shot classification like so:


```py
from transformers import AutoModelForSeq2SeqLM, AutoTokenizer

AutoModelForSeq2SeqLM.from_pretrained("jpelhaw/t5-word-sense-disambiguation")
AutoTokenizer.from_pretrained("jpelhaw/t5-word-sense-disambiguation")

input = 'question: which description describes the word " java " best in the following context? \
descriptions:[  " A drink consisting of an infusion of ground coffee beans " ,
                " a platform-independent programming lanugage "
                ,  or " an island in Indonesia to the south of Borneo " ]
context: I like to drink " java " in the morning .'

example = tokenizer.tokenize(input, add_special_tokens=True)

answer = model.generate(input_ids=example['input_ids'],
                                attention_mask=example['attention_mask'],
                                max_length=135)

# "a drink consisting of an infusion of ground coffee beans"
```


model name: t5-word-sense-disambiguation


model author: jpelhaw


task: text2text-generation


tags: pytorch, t5, text2text-generation, ISO 639-1 code for your language, or `multilingual`, dataset:array of dataset identifiers, arxiv:1910.10683, transformers, array, of, tags, autonlp_compatible


- array
- of
- tags
datasets:
- array of dataset identifiers
metrics:
- array of metric identifiers
widget:
- text: Copyright infringement is viewed as an infringement of scholarly uprightness
and a penetrate of editorial morals.


# XLNet-LMGC-M for Machine-Paraphrased Plagiarism Detection


This is the checkpoint for LMGC based on XLNet-base after being trained on the Machine-Paraphrased Plagiarism Dataset: [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.3608000.svg)](https://doi.org/10.5281/zenodo.3608000)


* [The xlnet-base model page](https://huggingface.co/xlnet-base-cased)
* [XLNet: Generalized Autoregressive Pretraining for Language Understanding](https://arxiv.org/pdf/1906.08237.pdf)


The model can be loaded to perform Plagiarism like so:


```py
from transformers import AutoModelForSequenceClassification, AutoTokenizer

AutoModelForSequenceClassification("jpelhaw/xlnet-base-plagiarism-detection")
AutoTokenizer.from_pretrained("jpelhaw/xlnet-base-plagiarism-detection")

input = 'Copyright infringement is viewed as an infringement of scholarly uprightness and a penetrate of editorial morals.'

example = tokenizer.tokenize(input, add_special_tokens=True)

answer = model(**example)

# "plagiarism"
```


model name: xlnet-base-plagiarism-detection


task: text-classification


tags: pytorch, xlnet, text-classification, ISO 639-1 code for your language, or `multilingual`, dataset:array of dataset identifiers, arxiv:1906.08237, transformers, array, of, tags


language: ISO 639-1 code for your language, or `multilingual`
thumbnail: url to a thumbnail used in social sharing
tags:


- array
- of
- tags
datasets:
- array of dataset identifiers
metrics:
- array of metric identifiers
widget:
- text: Plagiarism is the representation of another author's writing, thoughts, ideas,
or expressions as one's own work.


# Longformer-base for Word Sense Disambiguation


This is the checkpoint for Longformer-base after being trained on the [Machine-Paraphrased Plagiarism Dataset](https://doi.org/10.5281/zenodo.3608000)


Additional information about this model:


* [The longformer-base-4096 model page](https://huggingface.co/allenai/longformer-base-4096)
* [Longformer: The Long-Document Transformer](https://arxiv.org/pdf/2004.05150.pdf)
* [Official implementation by AllenAI](https://github.com/allenai/longformer)


```py
from transformers import AutoModelForSequenceClassification, AutoTokenizer

AutoModelForSequenceClassification("jpelhaw/longformer-base-plagiarism-detection")
AutoTokenizer.from_pretrained("jpelhaw/longformer-base-plagiarism-detection")

input = 'Plagiarism is the representation of another author's writing, thoughts, ideas, or expressions as one's own work.'

example = tokenizer.tokenize(input, add_special_tokens=True)

answer = model(**example)

# "plagiarised"
```


model name: longformer-base-plagiarism-detection


model author: jpelhaw


tags: pytorch, longformer, text-classification, ISO 639-1 code for your language, or `multilingual`, dataset:array of dataset identifiers, arxiv:2004.05150, transformers, array, of, tags


### SpaceBERT


This is one of the 3 further pre-trained models from the SpaceTransformers family presented in [SpaceTransformers: Language Modeling for Space Systems](https://ieeexplore.ieee.org/document/9548078). The original Git repo is [strath-ace/smart-nlp](https://github.com/strath-ace/smart-nlp).


The further pre-training corpus includes publications abstracts, books, and Wikipedia pages related to space systems. Corpus size is 14.3 GB. SpaceBERT was further pre-trained on this domain-specific corpus from [BERT-Base (uncased)](https://huggingface.co/bert-base-uncased). In our paper, it is then fine-tuned for a Concept Recognition task.


### BibTeX entry and citation info


```
@ARTICLE{
9548078,
author={Berquand, Audrey and Darm, Paul and Riccardi, Annalisa},
journal={IEEE Access},
title={SpaceTransformers: Language Modeling for Space Systems},
year={2021},
volume={9},
number={},
pages={133111-133122},
doi={10.1109/ACCESS.2021.3115659}
}
```


model name: spacebert


model author: icelab


task: fill-mask


tags: pytorch, bert, fill-mask, transformers, autonlp_compatible, infinity_compatible


### SpaceSciBERT


The further pre-training corpus includes publications abstracts, books, and Wikipedia pages related to space systems. Corpus size is 14.3 GB. SpaceSciBERT was further pre-trained on this domain-specific corpus from [SciBERT-SciVocab (uncased)](https://huggingface.co/allenai/scibert_scivocab_uncased). In our paper, it is then fine-tuned for a Concept Recognition task.


model name: spacescibert


widget:


- text: "The CubeSat RF design shall either have one RF inhibit and a RF power output no greater than 1.5W at the transmitter antenna's RF input OR the CubeSat shall have a minimum of two independent RF inhibits (CDS 3.3.9) (ISO 5.5.6)."


# spacescibert_CR


## Model desciption