Datasets:
davanstrien
/
pytorchmodelmetadata

Dataset card Data Studio Files
xet
Community
modelId
stringlengths
4
112
sha
stringlengths
40
40
lastModified
stringlengths
24
24
tags
sequence
pipeline_tag
stringclasses
29 values
private
bool
1 class
author
stringlengths
2
38
⌀
config
null
id
stringlengths
4
112
downloads
float64
0
36.8M
⌀
likes
float64
0
712
⌀
library_name
stringclasses
17 values
__index_level_0__
int64
0
38.5k
readme
stringlengths
0
186k
Intel/bert-base-uncased-sparse-90-unstructured-pruneofa
78f561a09cf292eb81a272620559a2cdbd5b4c60
2022-01-13T12:13:06.000Z
[ "pytorch", "tf", "bert", "pretraining", "en", "dataset:wikipedia", "dataset:bookcorpus", "arxiv:2111.05754", "transformers", "fill-mask" ]
fill-mask
false
Intel
null
Intel/bert-base-uncased-sparse-90-unstructured-pruneofa
647
null
transformers
2,100
--- language: en tags: fill-mask datasets: - wikipedia - bookcorpus --- # 90% Sparse BERT-Base (uncased) Prune OFA This model is a result from our paper [Prune Once for All: Sparse Pre-Trained Language Models](https://arxiv.org/abs/2111.05754) presented in ENLSP NeurIPS Workshop 2021. For further details on the model and its result, see our paper and our implementation available [here](https://github.com/IntelLabs/Model-Compression-Research-Package/tree/main/research/prune-once-for-all).
google/byt5-xl
d16d25238ca359c637f7915f40e808819fa34d75
2022-05-27T15:07:11.000Z
[ "pytorch", "tf", "t5", "text2text-generation", "multilingual", "af", "am", "ar", "az", "be", "bg", "bn", "ca", "ceb", "co", "cs", "cy", "da", "de", "el", "en", "eo", "es", "et", "eu", "fa", "fi", "fil", "fr", "fy", "ga", "gd", "gl", "gu", "ha", "haw", "hi", "hmn", "ht", "hu", "hy", "ig", "is", "it", "iw", "ja", "jv", "ka", "kk", "km", "kn", "ko", "ku", "ky", "la", "lb", "lo", "lt", "lv", "mg", "mi", "mk", "ml", "mn", "mr", "ms", "mt", "my", "ne", "nl", "no", "ny", "pa", "pl", "ps", "pt", "ro", "ru", "sd", "si", "sk", "sl", "sm", "sn", "so", "sq", "sr", "st", "su", "sv", "sw", "ta", "te", "tg", "th", "tr", "uk", "und", "ur", "uz", "vi", "xh", "yi", "yo", "zh", "zu", "dataset:mc4", "arxiv:1907.06292", "arxiv:2105.13626", "transformers", "license:apache-2.0", "autotrain_compatible" ]
text2text-generation
false
google
null
google/byt5-xl
647
2
transformers
2,101
--- language: - multilingual - af - am - ar - az - be - bg - bn - ca - ceb - co - cs - cy - da - de - el - en - eo - es - et - eu - fa - fi - fil - fr - fy - ga - gd - gl - gu - ha - haw - hi - hmn - ht - hu - hy - ig - is - it - iw - ja - jv - ka - kk - km - kn - ko - ku - ky - la - lb - lo - lt - lv - mg - mi - mk - ml - mn - mr - ms - mt - my - ne - nl - no - ny - pa - pl - ps - pt - ro - ru - sd - si - sk - sl - sm - sn - so - sq - sr - st - su - sv - sw - ta - te - tg - th - tr - uk - und - ur - uz - vi - xh - yi - yo - zh - zu datasets: - mc4 license: apache-2.0 --- # ByT5 - xl ByT5 is a tokenizer-free version of [Google's T5](https://ai.googleblog.com/2020/02/exploring-transfer-learning-with-t5.html) and generally follows the architecture of [MT5](https://huggingface.co/google/mt5-xl). ByT5 was only pre-trained on [mC4](https://www.tensorflow.org/datasets/catalog/c4#c4multilingual) excluding any supervised training with an average span-mask of 20 UTF-8 characters. Therefore, this model has to be fine-tuned before it is useable on a downstream task. ByT5 works especially well on noisy text data,*e.g.*, `google/byt5-xl` significantly outperforms [mt5-xl](https://huggingface.co/google/mt5-xl) on [TweetQA](https://arxiv.org/abs/1907.06292). Paper: [ByT5: Towards a token-free future with pre-trained byte-to-byte models](https://arxiv.org/abs/2105.13626) Authors: *Linting Xue, Aditya Barua, Noah Constant, Rami Al-Rfou, Sharan Narang, Mihir Kale, Adam Roberts, Colin Raffel* ## Example Inference ByT5 works on raw UTF-8 bytes and can be used without a tokenizer: ```python from transformers import T5ForConditionalGeneration import torch model = T5ForConditionalGeneration.from_pretrained('google/byt5-xl') input_ids = torch.tensor([list("Life is like a box of chocolates.".encode("utf-8"))]) + 3 # add 3 for special tokens labels = torch.tensor([list("La vie est comme une boîte de chocolat.".encode("utf-8"))]) + 3 # add 3 for special tokens loss = model(input_ids, labels=labels).loss # forward pass ``` For batched inference & training it is however recommended using a tokenizer class for padding: ```python from transformers import T5ForConditionalGeneration, AutoTokenizer model = T5ForConditionalGeneration.from_pretrained('google/byt5-xl') tokenizer = AutoTokenizer.from_pretrained('google/byt5-xl') model_inputs = tokenizer(["Life is like a box of chocolates.", "Today is Monday."], padding="longest", return_tensors="pt") labels = tokenizer(["La vie est comme une boîte de chocolat.", "Aujourd'hui c'est lundi."], padding="longest", return_tensors="pt").input_ids loss = model(**model_inputs, labels=labels).loss # forward pass ``` ## Abstract Most widely-used pre-trained language models operate on sequences of tokens corresponding to word or subword units. Encoding text as a sequence of tokens requires a tokenizer, which is typically created as an independent artifact from the model. Token-free models that instead operate directly on raw text (bytes or characters) have many benefits: they can process text in any language out of the box, they are more robust to noise, and they minimize technical debt by removing complex and error-prone text preprocessing pipelines. Since byte or character sequences are longer than token sequences, past work on token-free models has often introduced new model architectures designed to amortize the cost of operating directly on raw text. In this paper, we show that a standard Transformer architecture can be used with minimal modifications to process byte sequences. We carefully characterize the trade-offs in terms of parameter count, training FLOPs, and inference speed, and show that byte-level models are competitive with their token-level counterparts. We also demonstrate that byte-level models are significantly more robust to noise and perform better on tasks that are sensitive to spelling and pronunciation. As part of our contribution, we release a new set of pre-trained byte-level Transformer models based on the T5 architecture, as well as all code and data used in our experiments. ![model image](https://raw.githubusercontent.com/patrickvonplaten/scientific_images/master/ByT5.png)
apple/mobilevit-small
0d7593125591ad9c05a33e6115aad12aa8e956a2
2022-06-02T10:56:27.000Z
[ "pytorch", "coreml", "mobilevit", "image-classification", "dataset:imagenet-1k", "arxiv:2110.02178", "transformers", "vision", "license:other" ]
image-classification
false
apple
null
apple/mobilevit-small
647
2
transformers
2,102
--- license: other tags: - vision - image-classification datasets: - imagenet-1k widget: - src: https://huggingface.co/datasets/mishig/sample_images/resolve/main/tiger.jpg example_title: Tiger - src: https://huggingface.co/datasets/mishig/sample_images/resolve/main/teapot.jpg example_title: Teapot - src: https://huggingface.co/datasets/mishig/sample_images/resolve/main/palace.jpg example_title: Palace --- # MobileViT (small-sized model) MobileViT model pre-trained on ImageNet-1k at resolution 256x256. It was introduced in [MobileViT: Light-weight, General-purpose, and Mobile-friendly Vision Transformer](https://arxiv.org/abs/2110.02178) by Sachin Mehta and Mohammad Rastegari, and first released in [this repository](https://github.com/apple/ml-cvnets). The license used is [Apple sample code license](https://github.com/apple/ml-cvnets/blob/main/LICENSE). Disclaimer: The team releasing MobileViT did not write a model card for this model so this model card has been written by the Hugging Face team. ## Model description MobileViT is a light-weight, low latency convolutional neural network that combines MobileNetV2-style layers with a new block that replaces local processing in convolutions with global processing using transformers. As with ViT (Vision Transformer), the image data is converted into flattened patches before it is processed by the transformer layers. Afterwards, the patches are "unflattened" back into feature maps. This allows the MobileViT-block to be placed anywhere inside a CNN. MobileViT does not require any positional embeddings. ## Intended uses & limitations You can use the raw model for image classification. See the [model hub](https://huggingface.co/models?search=mobilevit) to look for fine-tuned versions on a task that interests you. ### How to use Here is how to use this model to classify an image of the COCO 2017 dataset into one of the 1,000 ImageNet classes: ```python from transformers import MobileViTFeatureExtractor, MobileViTForImageClassification from PIL import Image import requests url = "http://images.cocodataset.org/val2017/000000039769.jpg" image = Image.open(requests.get(url, stream=True).raw) feature_extractor = MobileViTFeatureExtractor.from_pretrained("apple/mobilevit-small") model = MobileViTForImageClassification.from_pretrained("apple/mobilevit-small") inputs = feature_extractor(images=image, return_tensors="pt") outputs = model(**inputs) logits = outputs.logits # model predicts one of the 1000 ImageNet classes predicted_class_idx = logits.argmax(-1).item() print("Predicted class:", model.config.id2label[predicted_class_idx]) ``` Currently, both the feature extractor and model support PyTorch. ## Training data The MobileViT model was pretrained on [ImageNet-1k](https://huggingface.co/datasets/imagenet-1k), a dataset consisting of 1 million images and 1,000 classes. ## Training procedure ### Preprocessing Training requires only basic data augmentation, i.e. random resized cropping and horizontal flipping. To learn multi-scale representations without requiring fine-tuning, a multi-scale sampler was used during training, with image sizes randomly sampled from: (160, 160), (192, 192), (256, 256), (288, 288), (320, 320). At inference time, images are resized/rescaled to the same resolution (288x288), and center-cropped at 256x256. Pixels are normalized to the range [0, 1]. Images are expected to be in BGR pixel order, not RGB. ### Pretraining The MobileViT networks are trained from scratch for 300 epochs on ImageNet-1k on 8 NVIDIA GPUs with an effective batch size of 1024 and learning rate warmup for 3k steps, followed by cosine annealing. Also used were label smoothing cross-entropy loss and L2 weight decay. Training resolution varies from 160x160 to 320x320, using multi-scale sampling. ## Evaluation results | Model | ImageNet top-1 accuracy | ImageNet top-5 accuracy | # params | URL | |------------------|-------------------------|-------------------------|-----------|-------------------------------------------------| | MobileViT-XXS | 69.0 | 88.9 | 1.3 M | https://huggingface.co/apple/mobilevit-xx-small | | MobileViT-XS | 74.8 | 92.3 | 2.3 M | https://huggingface.co/apple/mobilevit-x-small | | **MobileViT-S** | **78.4** | **94.1** | **5.6 M** | https://huggingface.co/apple/mobilevit-small | ### BibTeX entry and citation info ```bibtex @inproceedings{vision-transformer, title = {MobileViT: Light-weight, General-purpose, and Mobile-friendly Vision Transformer}, author = {Sachin Mehta and Mohammad Rastegari}, year = {2022}, URL = {https://arxiv.org/abs/2110.02178} } ```
mujeensung/roberta-base_mnli_bc
95821cdd08f947bf3b98c9e9e70237fd92e5a9e1
2022-02-13T05:13:00.000Z
[ "pytorch", "roberta", "text-classification", "en", "dataset:glue", "transformers", "generated_from_trainer", "license:mit", "model-index" ]
text-classification
false
mujeensung
null
mujeensung/roberta-base_mnli_bc
646
null
transformers
2,103
--- language: - en license: mit tags: - generated_from_trainer datasets: - glue metrics: - accuracy model-index: - name: roberta-base_mnli_bc results: - task: name: Text Classification type: text-classification dataset: name: GLUE MNLI type: glue args: mnli metrics: - name: Accuracy type: accuracy value: 0.9583768461882739 --- <!-- 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_mnli_bc This model is a fine-tuned version of [roberta-base](https://huggingface.co/roberta-base) on the GLUE MNLI dataset. It achieves the following results on the evaluation set: - Loss: 0.2125 - Accuracy: 0.9584 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 2e-05 - train_batch_size: 16 - eval_batch_size: 8 - seed: 42 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - num_epochs: 3.0 - mixed_precision_training: Native AMP ### Training results | Training Loss | Epoch | Step | Validation Loss | Accuracy | |:-------------:|:-----:|:-----:|:---------------:|:--------:| | 0.2015 | 1.0 | 16363 | 0.1820 | 0.9470 | | 0.1463 | 2.0 | 32726 | 0.1909 | 0.9559 | | 0.0768 | 3.0 | 49089 | 0.2117 | 0.9585 | ### Framework versions - Transformers 4.13.0 - Pytorch 1.10.1+cu111 - Datasets 1.17.0 - Tokenizers 0.10.3
ipuneetrathore/bert-base-cased-finetuned-finBERT
e07f59c31d6eee87029ce78deca877cb52484022
2021-05-19T20:30:58.000Z
[ "pytorch", "jax", "bert", "text-classification", "transformers" ]
text-classification
false
ipuneetrathore
null
ipuneetrathore/bert-base-cased-finetuned-finBERT
642
null
transformers
2,104
## FinBERT Code for importing and using this model is available [here](https://github.com/ipuneetrathore/BERT_models)
microsoft/trocr-small-stage1
49dfe6c53cb559599a7da463bdff8e3df0334d02
2022-07-01T07:39:23.000Z
[ "pytorch", "vision-encoder-decoder", "arxiv:2109.10282", "transformers", "trocr", "image-to-text" ]
image-to-text
false
microsoft
null
microsoft/trocr-small-stage1
642
1
transformers
2,105
--- tags: - trocr - image-to-text --- # TrOCR (small-sized model, pre-trained only) TrOCR pre-trained only model. It was introduced in the paper [TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models](https://arxiv.org/abs/2109.10282) by Li et al. and first released in [this repository](https://github.com/microsoft/unilm/tree/master/trocr). ## Model description The TrOCR model is an encoder-decoder model, consisting of an image Transformer as encoder, and a text Transformer as decoder. The image encoder was initialized from the weights of DeiT, while the text decoder was initialized from the weights of UniLM. Images are presented to the model as a sequence of fixed-size patches (resolution 16x16), which are linearly embedded. One also adds absolute position embeddings before feeding the sequence to the layers of the Transformer encoder. Next, the Transformer text decoder autoregressively generates tokens. ## Intended uses & limitations You can use the raw model for optical character recognition (OCR) on single text-line images. See the [model hub](https://huggingface.co/models?search=microsoft/trocr) to look for fine-tuned versions on a task that interests you. ### How to use Here is how to use this model in PyTorch: ```python from transformers import TrOCRProcessor, VisionEncoderDecoderModel from PIL import Image import requests import torch # load image from the IAM database url = 'https://fki.tic.heia-fr.ch/static/img/a01-122-02-00.jpg' image = Image.open(requests.get(url, stream=True).raw).convert("RGB") processor = TrOCRProcessor.from_pretrained('microsoft/trocr-small-stage1') model = VisionEncoderDecoderModel.from_pretrained('microsoft/trocr-small-stage1') # training pixel_values = processor(image, return_tensors="pt").pixel_values # Batch size 1 decoder_input_ids = torch.tensor([[model.config.decoder.decoder_start_token_id]]) outputs = model(pixel_values=pixel_values, decoder_input_ids=decoder_input_ids) ``` ### BibTeX entry and citation info ```bibtex @misc{li2021trocr, title={TrOCR: Transformer-based Optical Character Recognition with Pre-trained Models}, author={Minghao Li and Tengchao Lv and Lei Cui and Yijuan Lu and Dinei Florencio and Cha Zhang and Zhoujun Li and Furu Wei}, year={2021}, eprint={2109.10282}, archivePrefix={arXiv}, primaryClass={cs.CL} } ```
hfl/rbtl3
9cad8535fa548d05b09d43bb95eef67845981908
2021-05-19T19:22:46.000Z
[ "pytorch", "tf", "jax", "bert", "fill-mask", "zh", "arxiv:1906.08101", "arxiv:2004.13922", "transformers", "license:apache-2.0", "autotrain_compatible" ]
fill-mask
false
hfl
null
hfl/rbtl3
641
2
transformers
2,106
--- language: - zh tags: - bert license: "apache-2.0" --- # This is a re-trained 3-layer RoBERTa-wwm-ext-large model. ## Chinese BERT with Whole Word Masking For further accelerating Chinese natural language processing, we provide **Chinese pre-trained BERT with Whole Word Masking**. **[Pre-Training with Whole Word Masking for Chinese BERT](https://arxiv.org/abs/1906.08101)** Yiming Cui, Wanxiang Che, Ting Liu, Bing Qin, Ziqing Yang, Shijin Wang, Guoping Hu This repository is developed based on：https://github.com/google-research/bert You may also interested in, - Chinese BERT series: https://github.com/ymcui/Chinese-BERT-wwm - Chinese MacBERT: https://github.com/ymcui/MacBERT - Chinese ELECTRA: https://github.com/ymcui/Chinese-ELECTRA - Chinese XLNet: https://github.com/ymcui/Chinese-XLNet - Knowledge Distillation Toolkit - TextBrewer: https://github.com/airaria/TextBrewer More resources by HFL: https://github.com/ymcui/HFL-Anthology ## Citation If you find the technical report or resource is useful, please cite the following technical report in your paper. - Primary: https://arxiv.org/abs/2004.13922 ``` @inproceedings{cui-etal-2020-revisiting, title = "Revisiting Pre-Trained Models for {C}hinese Natural Language Processing", author = "Cui, Yiming and Che, Wanxiang and Liu, Ting and Qin, Bing and Wang, Shijin and Hu, Guoping", booktitle = "Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: Findings", month = nov, year = "2020", address = "Online", publisher = "Association for Computational Linguistics", url = "https://www.aclweb.org/anthology/2020.findings-emnlp.58", pages = "657--668", } ``` - Secondary: https://arxiv.org/abs/1906.08101 ``` @article{chinese-bert-wwm, title={Pre-Training with Whole Word Masking for Chinese BERT}, author={Cui, Yiming and Che, Wanxiang and Liu, Ting and Qin, Bing and Yang, Ziqing and Wang, Shijin and Hu, Guoping}, journal={arXiv preprint arXiv:1906.08101}, year={2019} } ```
dangvantuan/sentence-camembert-base
badc8d827cb0215b4a68b37445214acba26da2b1
2022-03-11T17:02:50.000Z
[ "pytorch", "camembert", "feature-extraction", "fr", "dataset:stsb_multi_mt", "arxiv:1908.10084", "transformers", "Text", "Sentence Similarity", "Sentence-Embedding", "camembert-base", "license:apache-2.0", "sentence-similarity", "model-index" ]
sentence-similarity
false
dangvantuan
null
dangvantuan/sentence-camembert-base
641
2
transformers
2,107
--- pipeline_tag: sentence-similarity language: fr datasets: - stsb_multi_mt tags: - Text - Sentence Similarity - Sentence-Embedding - camembert-base license: apache-2.0 model-index: - name: sentence-camembert-base by Van Tuan DANG results: - task: name: Sentence-Embedding type: Text Similarity dataset: name: Text Similarity fr type: stsb_multi_mt args: fr metrics: - name: Test Pearson correlation coefficient type: Pearson_correlation_coefficient value: xx.xx --- ## Pre-trained sentence embedding models are the state-of-the-art of Sentence Embeddings for French. Model is Fine-tuned using pre-trained [facebook/camembert-base](https://huggingface.co/camembert/camembert-base) and [Siamese BERT-Networks with 'sentences-transformers'](https://www.sbert.net/) on dataset [stsb](https://huggingface.co/datasets/stsb_multi_mt/viewer/fr/train) ## Usage The model can be used directly (without a language model) as follows: ```python from sentence_transformers import SentenceTransformer model = SentenceTransformer("dangvantuan/sentence-camembert-base") sentences = ["Un avion est en train de décoller.", "Un homme joue d'une grande flûte.", "Un homme étale du fromage râpé sur une pizza.", "Une personne jette un chat au plafond.", "Une personne est en train de plier un morceau de papier.", ] embeddings = model.encode(sentences) ``` ## Evaluation The model can be evaluated as follows on the French test data of stsb. ```python from sentence_transformers import SentenceTransformer from sentence_transformers.readers import InputExample from sentence_transformers.evaluation import EmbeddingSimilarityEvaluator from datasets import load_dataset def convert_dataset(dataset): dataset_samples=[] for df in dataset: score = float(df['similarity_score'])/5.0 # Normalize score to range 0 ... 1 inp_example = InputExample(texts=[df['sentence1'], df['sentence2']], label=score) dataset_samples.append(inp_example) return dataset_samples # Loading the dataset for evaluation df_dev = load_dataset("stsb_multi_mt", name="fr", split="dev") df_test = load_dataset("stsb_multi_mt", name="fr", split="test") # Convert the dataset for evaluation # For Dev set: dev_samples = convert_dataset(df_dev) val_evaluator = EmbeddingSimilarityEvaluator.from_input_examples(dev_samples, name='sts-dev') val_evaluator(model, output_path="./") # For Test set: test_samples = convert_dataset(df_test) test_evaluator = EmbeddingSimilarityEvaluator.from_input_examples(test_samples, name='sts-test') test_evaluator(model, output_path="./") ``` **Test Result**: The performance is measured using Pearson and Spearman correlation: - On dev | Model | Pearson correlation | Spearman correlation | #params | | ------------- | ------------- | ------------- |------------- | | [dangvantuan/sentence-camembert-base](https://huggingface.co/dangvantuan/sentence-camembert-base)| 86.73 |86.54 | 110M | | [distiluse-base-multilingual-cased](https://huggingface.co/sentence-transformers/distiluse-base-multilingual-cased) | 79.22 | 79.16|135M | - On test | Model | Pearson correlation | Spearman correlation | | ------------- | ------------- | ------------- | | [dangvantuan/sentence-camembert-base](https://huggingface.co/dangvantuan/sentence-camembert-base)| 82.36 | 81.64| | [distiluse-base-multilingual-cased](https://huggingface.co/sentence-transformers/distiluse-base-multilingual-cased) | 78.62 | 77.48| ## Citation @article{reimers2019sentence, title={Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks}, author={Nils Reimers, Iryna Gurevych}, journal={https://arxiv.org/abs/1908.10084}, year={2019} } @article{martin2020camembert, title={CamemBERT: a Tasty French Language Mode}, author={Martin, Louis and Muller, Benjamin and Su{\'a}rez, Pedro Javier Ortiz and Dupont, Yoann and Romary, Laurent and de la Clergerie, {\'E}ric Villemonte and Seddah, Djam{\'e} and Sagot, Beno{\^\i}t}, journal={Proceedings of the 58th Annual Meeting of the Association for Computational Linguistics}, year={2020} }
aubmindlab/araelectra-base-discriminator
5a6e787cdf3af77229d04a33f4a79c98fea35be1
2022-04-07T11:29:39.000Z
[ "pytorch", "tf", "tensorboard", "electra", "pretraining", "ar", "dataset:wikipedia", "dataset:OSIAN", "dataset:1.5B Arabic Corpus", "dataset:OSCAR Arabic Unshuffled", "arxiv:2012.15516", "transformers" ]
null
false
aubmindlab
null
aubmindlab/araelectra-base-discriminator
640
null
transformers
2,108
--- language: ar datasets: - wikipedia - OSIAN - 1.5B Arabic Corpus - OSCAR Arabic Unshuffled --- # AraELECTRA <img src="https://raw.githubusercontent.com/aub-mind/arabert/master/AraELECTRA.png" width="100" align="left"/> **ELECTRA** is a method for self-supervised language representation learning. It can be used to pre-train transformer networks using relatively little compute. ELECTRA models are trained to distinguish "real" input tokens vs "fake" input tokens generated by another neural network, similar to the discriminator of a [GAN](https://arxiv.org/pdf/1406.2661.pdf). AraELECTRA achieves state-of-the-art results on Arabic QA dataset. For a detailed description, please refer to the AraELECTRA paper [AraELECTRA: Pre-Training Text Discriminators for Arabic Language Understanding](https://arxiv.org/abs/2012.15516). ## How to use the discriminator in `transformers` ```python from transformers import ElectraForPreTraining, ElectraTokenizerFast import torch discriminator = ElectraForPreTraining.from_pretrained("aubmindlab/araelectra-base-discriminator") tokenizer = ElectraTokenizerFast.from_pretrained("aubmindlab/araelectra-base-discriminator") sentence = "" fake_sentence = "" fake_tokens = tokenizer.tokenize(fake_sentence) fake_inputs = tokenizer.encode(fake_sentence, return_tensors="pt") discriminator_outputs = discriminator(fake_inputs) predictions = torch.round((torch.sign(discriminator_outputs[0]) + 1) / 2) [print("%7s" % token, end="") for token in fake_tokens] [print("%7s" % int(prediction), end="") for prediction in predictions.tolist()] ``` # Model Model | HuggingFace Model Name | Size (MB/Params)| ---|:---:|:---: AraELECTRA-base-generator | [araelectra-base-generator](https://huggingface.co/aubmindlab/araelectra-base-generator) | 227MB/60M | AraELECTRA-base-discriminator | [araelectra-base-discriminator](https://huggingface.co/aubmindlab/araelectra-base-discriminator) | 516MB/135M | # Compute Model | Hardware | num of examples (seq len = 512) | Batch Size | Num of Steps | Time (in days) ---|:---:|:---:|:---:|:---:|:---: AraELECTRA-base | TPUv3-8 | - | 256 | 2M | 24 # Dataset The pretraining data used for the new **AraELECTRA** model is also used for **AraGPT2 and AraBERTv2**. The dataset consists of 77GB or 200,095,961 lines or 8,655,948,860 words or 82,232,988,358 chars (before applying Farasa Segmentation) For the new dataset we added the unshuffled OSCAR corpus, after we thoroughly filter it, to the previous dataset used in AraBERTv1 but with out the websites that we previously crawled: - OSCAR unshuffled and filtered. - [Arabic Wikipedia dump](https://archive.org/details/arwiki-20190201) from 2020/09/01 - [The 1.5B words Arabic Corpus](https://www.semanticscholar.org/paper/1.5-billion-words-Arabic-Corpus-El-Khair/f3eeef4afb81223df96575adadf808fe7fe440b4) - [The OSIAN Corpus](https://www.aclweb.org/anthology/W19-4619) - Assafir news articles. Huge thank you for Assafir for giving us the data # Preprocessing It is recommended to apply our preprocessing function before training/testing on any dataset. **Install farasapy to segment text for AraBERT v1 & v2 `pip install farasapy`** ```python from arabert.preprocess import ArabertPreprocessor model_name="araelectra-base" arabert_prep = ArabertPreprocessor(model_name=model_name) text = "ولن نبالغ إذا قلنا إن هاتف أو كمبيوتر المكتب في زمننا هذا ضروري" arabert_prep.preprocess(text) ``` # TensorFlow 1.x models **You can find the PyTorch, TF2 and TF1 models in HuggingFace's Transformer Library under the ```aubmindlab``` username** - `wget https://huggingface.co/aubmindlab/MODEL_NAME/resolve/main/tf1_model.tar.gz` where `MODEL_NAME` is any model under the `aubmindlab` name # If you used this model please cite us as : ``` @inproceedings{antoun-etal-2021-araelectra, title = "{A}ra{ELECTRA}: Pre-Training Text Discriminators for {A}rabic Language Understanding", author = "Antoun, Wissam and Baly, Fady and Hajj, Hazem", booktitle = "Proceedings of the Sixth Arabic Natural Language Processing Workshop", month = apr, year = "2021", address = "Kyiv, Ukraine (Virtual)", publisher = "Association for Computational Linguistics", url = "https://www.aclweb.org/anthology/2021.wanlp-1.20", pages = "191--195", } ``` # Acknowledgments Thanks to TensorFlow Research Cloud (TFRC) for the free access to Cloud TPUs, couldn't have done it without this program, and to the [AUB MIND Lab](https://sites.aub.edu.lb/mindlab/) Members for the continous support. Also thanks to [Yakshof](https://www.yakshof.com/#/) and Assafir for data and storage access. Another thanks for Habib Rahal (https://www.behance.net/rahalhabib), for putting a face to AraBERT. # Contacts **Wissam Antoun**: [Linkedin](https://www.linkedin.com/in/wissam-antoun-622142b4/) | [Twitter](https://twitter.com/wissam_antoun) | [Github](https://github.com/WissamAntoun) | <[email protected]> | <[email protected]> **Fady Baly**: [Linkedin](https://www.linkedin.com/in/fadybaly/) | [Twitter](https://twitter.com/fadybaly) | [Github](https://github.com/fadybaly) | <[email protected]> | <[email protected]>
cambridgeltl/SapBERT-UMLS-2020AB-all-lang-from-XLMR-large
fbed3159be2544640d2300f9b8851243b1426aa9
2021-05-27T18:49:10.000Z
[ "pytorch", "xlm-roberta", "feature-extraction", "arxiv:2010.11784", "transformers" ]
feature-extraction
false
cambridgeltl
null
cambridgeltl/SapBERT-UMLS-2020AB-all-lang-from-XLMR-large
640
null
transformers
2,109
--- language: multilingual tags: - biomedical - lexical-semantics - cross-lingual datasets: - UMLS **[news]** A cross-lingual extension of SapBERT will appear in the main onference of **ACL 2021**! <br> **[news]** SapBERT will appear in the conference proceedings of **NAACL 2021**! ### SapBERT-XLMR SapBERT [(Liu et al. 2021)](https://arxiv.org/pdf/2010.11784.pdf) trained with [UMLS](https://www.nlm.nih.gov/research/umls/licensedcontent/umlsknowledgesources.html) 2020AB, using [xlm-roberta-large](https://huggingface.co/xlm-roberta-large) as the base model. Please use [CLS] as the representation of the input. ### Citation ```bibtex @inproceedings{liu2021learning, title={Learning Domain-Specialised Representations for Cross-Lingual Biomedical Entity Linking}, author={Liu, Fangyu and Vuli{\'c}, Ivan and Korhonen, Anna and Collier, Nigel}, booktitle={Proceedings of ACL-IJCNLP 2021}, month = aug, year={2021} } ```
cahya/bert2gpt-indonesian-summarization
5edc210dbf2b92225b38aad9959648fd4ad3b3a5
2021-02-08T16:19:50.000Z
[ "pytorch", "encoder-decoder", "text2text-generation", "id", "dataset:id_liputan6", "transformers", "pipeline:summarization", "summarization", "bert2gpt", "license:apache-2.0", "autotrain_compatible" ]
summarization
false
cahya
null
cahya/bert2gpt-indonesian-summarization
639
1
transformers
2,110
--- language: id tags: - pipeline:summarization - summarization - bert2gpt datasets: - id_liputan6 license: apache-2.0 --- # Indonesian BERT2BERT Summarization Model Finetuned EncoderDecoder model using BERT-base and GPT2-small for Indonesian text summarization. ## Finetuning Corpus `bert2gpt-indonesian-summarization` model is based on `cahya/bert-base-indonesian-1.5G` and `cahya/gpt2-small-indonesian-522M`by [cahya](https://huggingface.co/cahya), finetuned using [id_liputan6](https://huggingface.co/datasets/id_liputan6) dataset. ## Load Finetuned Model ```python from transformers import BertTokenizer, EncoderDecoderModel tokenizer = BertTokenizer.from_pretrained("cahya/bert2gpt-indonesian-summarization") tokenizer.bos_token = tokenizer.cls_token tokenizer.eos_token = tokenizer.sep_token model = EncoderDecoderModel.from_pretrained("cahya/bert2gpt-indonesian-summarization") ``` ## Code Sample ```python from transformers import BertTokenizer, EncoderDecoderModel tokenizer = BertTokenizer.from_pretrained("cahya/bert2gpt-indonesian-summarization") tokenizer.bos_token = tokenizer.cls_token tokenizer.eos_token = tokenizer.sep_token model = EncoderDecoderModel.from_pretrained("cahya/bert2gpt-indonesian-summarization") # ARTICLE_TO_SUMMARIZE = "" # generate summary input_ids = tokenizer.encode(ARTICLE_TO_SUMMARIZE, return_tensors='pt') summary_ids = model.generate(input_ids, min_length=20, max_length=80, num_beams=10, repetition_penalty=2.5, length_penalty=1.0, early_stopping=True, no_repeat_ngram_size=2, use_cache=True, do_sample = True, temperature = 0.8, top_k = 50, top_p = 0.95) summary_text = tokenizer.decode(summary_ids[0], skip_special_tokens=True) print(summary_text) ``` Output: ``` ```
castorini/tct_colbert-msmarco
dab1fa241ee2cdf8d5db9dca5757d27b9a37fb3b
2021-04-21T01:29:30.000Z
[ "pytorch", "arxiv:2010.11386", "transformers" ]
null
false
castorini
null
castorini/tct_colbert-msmarco
639
null
transformers
2,111
This model is to reproduce the TCT-ColBERT dense retrieval described in the following paper: > Sheng-Chieh Lin, Jheng-Hong Yang, and Jimmy Lin. [Distilling Dense Representations for Ranking using Tightly-Coupled Teachers.](https://arxiv.org/abs/2010.11386) arXiv:2010.11386, October 2020. For more details on how to use it, check our experiments in [Pyserini](https://github.com/castorini/pyserini/blob/master/docs/experiments-tct_colbert.md)
patrickvonplaten/data2vec-audio-base-10m-4-gram
26f757bde83d157bdd8589ca9dec004938bfe5eb
2022-04-20T10:33:08.000Z
[ "pytorch", "data2vec-audio", "automatic-speech-recognition", "en", "dataset:librispeech_asr", "arxiv:2202.03555", "transformers", "speech", "license:apache-2.0" ]
automatic-speech-recognition
false
patrickvonplaten
null
patrickvonplaten/data2vec-audio-base-10m-4-gram
638
null
transformers
2,112
--- language: en datasets: - librispeech_asr tags: - speech license: apache-2.0 --- # Data2Vec-Audio-Base-10m [Facebook's Data2Vec](https://ai.facebook.com/research/data2vec-a-general-framework-for-self-supervised-learning-in-speech-vision-and-language/) The base model pretrained and fine-tuned on 10 minutes of Librispeech on 16kHz sampled speech audio. When using the model make sure that your speech input is also sampled at 16Khz. [Paper](https://arxiv.org/abs/2202.03555) Authors: Alexei Baevski, Wei-Ning Hsu, Qiantong Xu, Arun Babu, Jiatao Gu, Michael Auli **Abstract** While the general idea of self-supervised learning is identical across modalities, the actual algorithms and objectives differ widely because they were developed with a single modality in mind. To get us closer to general self-supervised learning, we present data2vec, a framework that uses the same learning method for either speech, NLP or computer vision. The core idea is to predict latent representations of the full input data based on a masked view of the input in a self-distillation setup using a standard Transformer architecture. Instead of predicting modality-specific targets such as words, visual tokens or units of human speech which are local in nature, data2vec predicts contextualized latent representations that contain information from the entire input. Experiments on the major benchmarks of speech recognition, image classification, and natural language understanding demonstrate a new state of the art or competitive performance to predominant approaches. The original model can be found under https://github.com/pytorch/fairseq/tree/main/examples/data2vec . # Pre-Training method ![model image](https://raw.githubusercontent.com/patrickvonplaten/scientific_images/master/data2vec.png) For more information, please take a look at the [official paper](https://arxiv.org/abs/2202.03555). # Usage To transcribe audio files the model can be used as a standalone acoustic model as follows: ```python from transformers import Wav2Vec2Processor, Data2VecForCTC from datasets import load_dataset import torch # load model and processor processor = Wav2Vec2Processor.from_pretrained("facebook/data2vec-audio-base-10m") model = Data2VecForCTC.from_pretrained("facebook/data2vec-audio-base-10m") # load dummy dataset and read soundfiles ds = load_dataset("patrickvonplaten/librispeech_asr_dummy", "clean", split="validation") # tokenize input_values = processor(ds[0]["audio"]["array"],, return_tensors="pt", padding="longest").input_values # Batch size 1 # retrieve logits logits = model(input_values).logits # take argmax and decode predicted_ids = torch.argmax(logits, dim=-1) transcription = processor.batch_decode(predicted_ids) ```
Maklygin/mBert-relation-extraction-FT
63e8e267f4fbcbc4c5c800e33880aac64a3b2807
2022-06-08T10:38:59.000Z
[ "pytorch", "bert", "text-classification", "transformers" ]
text-classification
false
Maklygin
null
Maklygin/mBert-relation-extraction-FT
638
null
transformers
2,113
Entry not found
sonoisa/t5-base-japanese-question-generation
a529078d993205a1c61e8a7be08f6f640de10243
2022-03-11T02:50:33.000Z
[ "pytorch", "t5", "text2text-generation", "ja", "transformers", "seq2seq", "license:cc-by-sa-4.0", "autotrain_compatible" ]
text2text-generation
false
sonoisa
null
sonoisa/t5-base-japanese-question-generation
637
null
transformers
2,114
--- language: ja tags: - t5 - text2text-generation - seq2seq license: cc-by-sa-4.0 widget: - text: "answer: アマビエ context: アマビエ（歴史的仮名遣：アマビヱ）は、日本に伝わる半人半魚の妖怪。光輝く姿で海中から現れ、豊作や疫病などの予言をすると伝えられている。江戸時代後期の肥後国（現・熊本県）に現れたという。この話は挿図付きで瓦版に取り上げられ、遠く江戸にまで伝えられた。弘化3年4月中旬（1846年5月上旬）のこと、毎夜、海中に光る物体が出没していたため、役人が赴いたところ、それが姿を現した。姿形について言葉では書き留められていないが、挿図が添えられている。 その者は、役人に対して「私は海中に住むアマビエと申す者なり」と名乗り、「当年より6ヶ年の間は諸国で豊作が続くが疫病も流行する。私の姿を描いた絵を人々に早々に見せよ。」と予言めいたことを告げ、海の中へと帰って行った。年代が特定できる最古の例は、天保15年（1844年）の越後国（現・新潟県）に出現した「海彦（読みの推定：あまびこ）」を記述した瓦版（『坪川本』という。福井県立図書館所蔵）、その挿絵に描かれた海彦は、頭からいきなり3本の足が生えた（胴体のない）形状で、人間のような耳をし、目はまるく、口が突出している。その年中に日本人口の7割の死滅を予言し、その像の絵札による救済を忠告している。" --- # 回答と回答が出てくるパラグラフを与えると質問文を生成するモデル SEE: https://github.com/sonoisa/deep-question-generation ## 本モデルの作成ステップ概要 1. [SQuAD 1.1](https://rajpurkar.github.io/SQuAD-explorer/)を日本語に機械翻訳し、不正なデータをクレンジング（有効なデータは約半分）。 回答が含まれるコンテキスト、質問文、解答の3つ組ができる。 2. [日本語T5モデル](https://huggingface.co/sonoisa/t5-base-japanese)を次の設定でファインチューニング * 入力: "answer: {解答} content: {回答が含まれるコンテキスト}" * 出力: "{質問文}" * 各種ハイパーパラメータ * 最大入力トークン数: 512 * 最大出力トークン数: 64 * 最適化アルゴリズム: AdaFactor * 学習率: 0.001（固定） * バッチサイズ: 128 * ステップ数: 2500（500ステップごとにチェックポイントを出力、定量・定性評価を行い2500ステップ目を採用）
sangrimlee/bert-base-multilingual-cased-korquad
be8790035bd1fed7074dd2efdf4cb97ebd8e225d
2021-05-20T04:47:57.000Z
[ "pytorch", "jax", "bert", "question-answering", "transformers", "autotrain_compatible" ]
question-answering
false
sangrimlee
null
sangrimlee/bert-base-multilingual-cased-korquad
635
null
transformers
2,115
Entry not found
ckiplab/albert-base-chinese-ner
ef1b19225fc53f10fafd8bfdefb41ac2f2f4e177
2022-05-10T03:28:08.000Z
[ "pytorch", "albert", "token-classification", "zh", "transformers", "license:gpl-3.0", "autotrain_compatible" ]
token-classification
false
ckiplab
null
ckiplab/albert-base-chinese-ner
634
0
transformers
2,116
--- language: - zh thumbnail: https://ckip.iis.sinica.edu.tw/files/ckip_logo.png tags: - pytorch - token-classification - albert - zh license: gpl-3.0 --- # CKIP ALBERT Base Chinese This project provides traditional Chinese transformers models (including ALBERT, BERT, GPT2) and NLP tools (including word segmentation, part-of-speech tagging, named entity recognition). 這個專案提供了繁體中文的 transformers 模型（包含 ALBERT、BERT、GPT2）及自然語言處理工具（包含斷詞、詞性標記、實體辨識）。 ## Homepage - https://github.com/ckiplab/ckip-transformers ## Contributers - [Mu Yang](https://muyang.pro) at [CKIP](https://ckip.iis.sinica.edu.tw) (Author & Maintainer) ## Usage Please use BertTokenizerFast as tokenizer instead of AutoTokenizer. 請使用 BertTokenizerFast 而非 AutoTokenizer。 ``` from transformers import ( BertTokenizerFast, AutoModel, ) tokenizer = BertTokenizerFast.from_pretrained('bert-base-chinese') model = AutoModel.from_pretrained('ckiplab/albert-base-chinese-ner') ``` For full usage and more information, please refer to https://github.com/ckiplab/ckip-transformers. 有關完整使用方法及其他資訊，請參見 https://github.com/ckiplab/ckip-transformers 。
mpariente/DPRNNTasNet-ks2_WHAM_sepclean
548f4f1c9476ed0af6b4bea3403247c71d5d7d46
2021-09-23T16:12:22.000Z
[ "pytorch", "dataset:wham", "dataset:sep_clean", "asteroid", "audio", "DPRNNTasNet", "audio-to-audio", "license:cc-by-sa-4.0" ]
audio-to-audio
false
mpariente
null
mpariente/DPRNNTasNet-ks2_WHAM_sepclean
634
4
asteroid
2,117
--- tags: - asteroid - audio - DPRNNTasNet - audio-to-audio datasets: - wham - sep_clean license: cc-by-sa-4.0 --- ## Asteroid model `mpariente/DPRNNTasNet-ks2_WHAM_sepclean` Imported from [Zenodo](https://zenodo.org/record/3862942) ### Description: This model was trained by Manuel Pariente using the wham/DPRNN recipe in [Asteroid](https://github.com/asteroid-team/asteroid). It was trained on the `sep_clean` task of the WHAM! dataset. ### Training config: ```yaml data: mode: min nondefault_nsrc: None sample_rate: 8000 segment: 2.0 task: sep_clean train_dir: data/wav8k/min/tr valid_dir: data/wav8k/min/cv filterbank: kernel_size: 2 n_filters: 64 stride: 1 main_args: exp_dir: exp/train_dprnn_new/ gpus: -1 help: None masknet: bidirectional: True bn_chan: 128 chunk_size: 250 dropout: 0 hid_size: 128 hop_size: 125 in_chan: 64 mask_act: sigmoid n_repeats: 6 n_src: 2 out_chan: 64 optim: lr: 0.001 optimizer: adam weight_decay: 1e-05 positional arguments: training: batch_size: 3 early_stop: True epochs: 200 gradient_clipping: 5 half_lr: True num_workers: 8 ``` ### Results: ```yaml si_sdr: 19.316743490695334 si_sdr_imp: 19.317895273889842 sdr: 19.68085347190952 sdr_imp: 19.5298092932871 sir: 30.362213998701232 sir_imp: 30.21116982007881 sar: 20.15553251343315 sar_imp: -129.02091762351188 stoi: 0.97772664309074 stoi_imp: 0.23968091518217424 ``` ### License notice: This work "DPRNNTasNet-ks2_WHAM_sepclean" is a derivative of [CSR-I (WSJ0) Complete](https://catalog.ldc.upenn.edu/LDC93S6A) by [LDC](https://www.ldc.upenn.edu/), used under [LDC User Agreement for Non-Members](https://catalog.ldc.upenn.edu/license/ldc-non-members-agreement.pdf) (Research only). "DPRNNTasNet-ks2_WHAM_sepclean" is licensed under [Attribution-ShareAlike 3.0 Unported](https://creativecommons.org/licenses/by-sa/3.0/) by Manuel Pariente.
skytnt/gpt2-japanese-lyric-small
72268b60df9c19098f3acf526221d06838d317f3
2022-07-06T05:06:29.000Z
[ "pytorch", "tf", "gpt2", "text-generation", "ja", "transformers", "japanese", "lm", "nlp", "license:mit" ]
text-generation
false
skytnt
null
skytnt/gpt2-japanese-lyric-small
634
1
transformers
2,118
--- language: ja tags: - ja - japanese - gpt2 - text-generation - lm - nlp license: mit widget: - text: "桜が咲く" --- # Japanese GPT2 Lyric Model ## Model description The model is used to generate Japanese lyrics. You can try it on my website [https://lyric.fab.moe/](https://lyric.fab.moe/#/) ## How to use ```python import torch from transformers import T5Tokenizer, GPT2LMHeadModel tokenizer = T5Tokenizer.from_pretrained("skytnt/gpt2-japanese-lyric-small") model = GPT2LMHeadModel.from_pretrained("skytnt/gpt2-japanese-lyric-small") def gen_lyric(prompt_text: str): prompt_text = "<s>" + prompt_text.replace("\n", "\\n ") prompt_tokens = tokenizer.tokenize(prompt_text) prompt_token_ids = tokenizer.convert_tokens_to_ids(prompt_tokens) prompt_tensor = torch.LongTensor(prompt_token_ids).to(device) prompt_tensor = prompt_tensor.view(1, -1) # model forward output_sequences = model.generate( input_ids=prompt_tensor, max_length=512, top_p=0.95, top_k=40, temperature=1.0, do_sample=True, early_stopping=True, bos_token_id=tokenizer.bos_token_id, eos_token_id=tokenizer.eos_token_id, pad_token_id=tokenizer.pad_token_id, num_return_sequences=1 ) # convert model outputs to readable sentence generated_sequence = output_sequences.tolist()[0] generated_tokens = tokenizer.convert_ids_to_tokens(generated_sequence) generated_text = tokenizer.convert_tokens_to_string(generated_tokens) generated_text = "\n".join([s.strip() for s in generated_text.split('\\n')]).replace(' ', '\u3000').replace('<s>', '').replace('</s>', '\n\n---end---') return generated_text print(gen_lyric("桜が咲く")) ``` ## Training data [Training data](https://github.com/SkyTNT/gpt2-japanese-lyric/raw/main/lyric_clean.pkl) contains 143,587 Japanese lyrics which are collected from [uta-net](https://www.uta-net.com/) by [lyric_download](https://github.com/SkyTNT/lyric_downlowd)
huggingtweets/bestmusiclyric
3f3c6a02e8f161cdb28ac5a33b79f25e967300df
2021-05-21T20:32:09.000Z
[ "pytorch", "jax", "gpt2", "text-generation", "en", "transformers", "huggingtweets" ]
text-generation
false
huggingtweets
null
huggingtweets/bestmusiclyric
633
null
transformers
2,119
--- language: en thumbnail: https://www.huggingtweets.com/bestmusiclyric/1620313468667/predictions.png tags: - huggingtweets widget: - text: "My dream is" --- <div> <div style="width: 132px; height:132px; border-radius: 50%; background-size: cover; background-image: url('https://pbs.twimg.com/profile_images/2113290180/images-1_400x400.jpeg')"> </div> <div style="margin-top: 8px; font-size: 19px; font-weight: 800">Best Music Lyric 🤖 AI Bot </div> <div style="font-size: 15px">@bestmusiclyric bot</div> </div> I was made with [huggingtweets](https://github.com/borisdayma/huggingtweets). Create your own bot based on your favorite user with [the demo](https://colab.research.google.com/github/borisdayma/huggingtweets/blob/master/huggingtweets-demo.ipynb)! ## How does it work? The model uses the following pipeline. ![pipeline](https://github.com/borisdayma/huggingtweets/blob/master/img/pipeline.png?raw=true) To understand how the model was developed, check the [W&B report](https://wandb.ai/wandb/huggingtweets/reports/HuggingTweets-Train-a-Model-to-Generate-Tweets--VmlldzoxMTY5MjI). ## Training data The model was trained on [@bestmusiclyric's tweets](https://twitter.com/bestmusiclyric). | Data | Quantity | | --- | --- | | Tweets downloaded | 3244 | | Retweets | 1060 | | Short tweets | 853 | | Tweets kept | 1331 | [Explore the data](https://wandb.ai/wandb/huggingtweets/runs/1ilv29ew/artifacts), which is tracked with [W&B artifacts](https://docs.wandb.com/artifacts) at every step of the pipeline. ## Training procedure The model is based on a pre-trained [GPT-2](https://huggingface.co/gpt2) which is fine-tuned on @bestmusiclyric's tweets. Hyperparameters and metrics are recorded in the [W&B training run](https://wandb.ai/wandb/huggingtweets/runs/1wqx12s6) for full transparency and reproducibility. At the end of training, [the final model](https://wandb.ai/wandb/huggingtweets/runs/1wqx12s6/artifacts) is logged and versioned. ## How to use You can use this model directly with a pipeline for text generation: ```python from transformers import pipeline generator = pipeline('text-generation', model='huggingtweets/bestmusiclyric') generator("My dream is", num_return_sequences=5) ``` ## Limitations and bias The model suffers from [the same limitations and bias as GPT-2](https://huggingface.co/gpt2#limitations-and-bias). In addition, the data present in the user's tweets further affects the text generated by the model. ## About *Built by Boris Dayma* [![Follow](https://img.shields.io/twitter/follow/borisdayma?style=social)](https://twitter.com/intent/follow?screen_name=borisdayma) For more details, visit the project repository. [![GitHub stars](https://img.shields.io/github/stars/borisdayma/huggingtweets?style=social)](https://github.com/borisdayma/huggingtweets)
razent/cotext-1-ccg
4dd36fb68b1e40fcc17877a69cf491731ddf82b3
2022-03-15T03:03:39.000Z
[ "pytorch", "tf", "jax", "t5", "feature-extraction", "code", "dataset:code_search_net", "transformers" ]
feature-extraction
false
razent
null
razent/cotext-1-ccg
633
null
transformers
2,120
--- language: code datasets: - code_search_net --- # CoText (1-CCG) ## Introduction Paper: [CoTexT: Multi-task Learning with Code-Text Transformer](https://aclanthology.org/2021.nlp4prog-1.5.pdf) Authors: _Long Phan, Hieu Tran, Daniel Le, Hieu Nguyen, James Anibal, Alec Peltekian, Yanfang Ye_ ## How to use Supported languages: ```shell "go" "java" "javascript" "php" "python" "ruby" ``` For more details, do check out [our Github repo](https://github.com/justinphan3110/CoTexT). ```python from transformers import AutoTokenizer, AutoModelForSeq2SeqLM ​ tokenizer = AutoTokenizer.from_pretrained("razent/cotext-1-ccg") model = AutoModelForSeq2SeqLM.from_pretrained("razent/cotext-1-ccg") ​ sentence = "def add(a, b): return a + b" text = "python: " + sentence + " </s>" encoding = tokenizer.encode_plus(text, pad_to_max_length=True, return_tensors="pt") input_ids, attention_masks = encoding["input_ids"].to("cuda"), encoding["attention_mask"].to("cuda") outputs = model.generate( input_ids=input_ids, attention_mask=attention_masks, max_length=256, early_stopping=True ) for output in outputs: line = tokenizer.decode(output, skip_special_tokens=True, clean_up_tokenization_spaces=True) print(line) ``` ## Citation ``` @inproceedings{phan-etal-2021-cotext, title = "{C}o{T}ex{T}: Multi-task Learning with Code-Text Transformer", author = "Phan, Long and Tran, Hieu and Le, Daniel and Nguyen, Hieu and Annibal, James and Peltekian, Alec and Ye, Yanfang", booktitle = "Proceedings of the 1st Workshop on Natural Language Processing for Programming (NLP4Prog 2021)", month = aug, year = "2021", address = "Online", publisher = "Association for Computational Linguistics", url = "https://aclanthology.org/2021.nlp4prog-1.5", doi = "10.18653/v1/2021.nlp4prog-1.5", pages = "40--47" } ```
Helsinki-NLP/opus-mt-mt-en
ba70458e94b4532f79e8ae01fa78ccbcab1cc143
2021-09-10T13:58:23.000Z
[ "pytorch", "tf", "jax", "marian", "text2text-generation", "mt", "en", "transformers", "translation", "license:apache-2.0", "autotrain_compatible" ]
translation
false
Helsinki-NLP
null
Helsinki-NLP/opus-mt-mt-en
631
null
transformers
2,121
--- tags: - translation license: apache-2.0 --- ### opus-mt-mt-en * source languages: mt * target languages: en * OPUS readme: [mt-en](https://github.com/Helsinki-NLP/OPUS-MT-train/blob/master/models/mt-en/README.md) * dataset: opus * model: transformer-align * pre-processing: normalization + SentencePiece * download original weights: [opus-2020-01-16.zip](https://object.pouta.csc.fi/OPUS-MT-models/mt-en/opus-2020-01-16.zip) * test set translations: [opus-2020-01-16.test.txt](https://object.pouta.csc.fi/OPUS-MT-models/mt-en/opus-2020-01-16.test.txt) * test set scores: [opus-2020-01-16.eval.txt](https://object.pouta.csc.fi/OPUS-MT-models/mt-en/opus-2020-01-16.eval.txt) ## Benchmarks | testset | BLEU | chr-F | |-----------------------|-------|-------| | JW300.mt.en | 49.0 | 0.655 | | Tatoeba.mt.en | 53.3 | 0.685 |
IDEA-CCNL/Erlangshen-MegatronBert-1.3B-NLI
33f5a544081f90a7a3ce1f666b08b65d12398d45
2022-05-16T06:06:42.000Z
[ "pytorch", "megatron-bert", "text-classification", "zh", "transformers", "bert", "NLU", "NLI", "license:apache-2.0" ]
text-classification
false
IDEA-CCNL
null
IDEA-CCNL/Erlangshen-MegatronBert-1.3B-NLI
631
null
transformers
2,122
--- language: - zh license: apache-2.0 tags: - bert - NLU - NLI inference: true widget: - text: "今天心情不好[SEP]今天很开心" --- # Erlangshen-MegatronBert-1.3B-NLI, model (Chinese)，one model of [Fengshenbang-LM](https://github.com/IDEA-CCNL/Fengshenbang-LM). We collect 4 NLI（Natural Language Inference） datasets in the Chinese domain for finetune, with a total of 1014787 samples. Our model is mainly based on [roberta](https://huggingface.co/hfl/chinese-roberta-wwm-ext) ## Usage ```python from transformers import AutoModelForSequenceClassification from transformers import BertTokenizer import torch tokenizer=BertTokenizer.from_pretrained('IDEA-CCNL/Erlangshen-MegatronBert-1.3B-NLI') model=AutoModelForSequenceClassification.from_pretrained('IDEA-CCNL/Erlangshen-MegatronBert-1.3B-NLI') texta='今天的饭不好吃' textb='今天心情不好' output=model(torch.tensor([tokenizer.encode(texta,textb)])) print(torch.nn.functional.softmax(output.logits,dim=-1)) ``` ## Scores on downstream chinese tasks (without any data augmentation) | Model | cmnli | ocnli | snli | | :--------: | :-----: | :----: | :-----: | | Erlangshen-Roberta-110M-NLI | 80.83 | 78.56 | 88.01 | | Erlangshen-Roberta-330M-NLI | 82.25 | 79.82 | 88 | | Erlangshen-MegatronBert-1.3B-NLI | 84.52 | 84.17 | 88.67 | ## Citation If you find the resource is useful, please cite the following website in your paper. ``` @misc{Fengshenbang-LM, title={Fengshenbang-LM}, author={IDEA-CCNL}, year={2021}, howpublished={\url{https://github.com/IDEA-CCNL/Fengshenbang-LM}}, } ```
sshleifer/distilbart-xsum-9-6
28dfbe915f475094642bf8c7dba2ba8a8e85b432
2021-06-14T08:26:18.000Z
[ "pytorch", "jax", "bart", "text2text-generation", "en", "dataset:cnn_dailymail", "dataset:xsum", "transformers", "summarization", "license:apache-2.0", "autotrain_compatible" ]
summarization
false
sshleifer
null
sshleifer/distilbart-xsum-9-6
630
null
transformers
2,123
--- language: en tags: - summarization license: apache-2.0 datasets: - cnn_dailymail - xsum thumbnail: https://huggingface.co/front/thumbnails/distilbart_medium.png --- ### Usage This checkpoint should be loaded into `BartForConditionalGeneration.from_pretrained`. See the [BART docs](https://huggingface.co/transformers/model_doc/bart.html?#transformers.BartForConditionalGeneration) for more information. ### Metrics for DistilBART models | Model Name | MM Params | Inference Time (MS) | Speedup | Rouge 2 | Rouge-L | |:---------------------------|------------:|----------------------:|----------:|----------:|----------:| | distilbart-xsum-12-1 | 222 | 90 | 2.54 | 18.31 | 33.37 | | distilbart-xsum-6-6 | 230 | 132 | 1.73 | 20.92 | 35.73 | | distilbart-xsum-12-3 | 255 | 106 | 2.16 | 21.37 | 36.39 | | distilbart-xsum-9-6 | 268 | 136 | 1.68 | 21.72 | 36.61 | | bart-large-xsum (baseline) | 406 | 229 | 1 | 21.85 | 36.50 | | distilbart-xsum-12-6 | 306 | 137 | 1.68 | 22.12 | 36.99 | | bart-large-cnn (baseline) | 406 | 381 | 1 | 21.06 | 30.63 | | distilbart-12-3-cnn | 255 | 214 | 1.78 | 20.57 | 30.00 | | distilbart-12-6-cnn | 306 | 307 | 1.24 | 21.26 | 30.59 | | distilbart-6-6-cnn | 230 | 182 | 2.09 | 20.17 | 29.70 |
akdeniz27/deberta-v2-xlarge-cuad
7713ed1048a69873812a8fc431669d96ea5315bf
2021-11-14T08:43:11.000Z
[ "pytorch", "deberta-v2", "question-answering", "en", "dataset:cuad", "transformers", "autotrain_compatible" ]
question-answering
false
akdeniz27
null
akdeniz27/deberta-v2-xlarge-cuad
629
null
transformers
2,124
--- language: en datasets: - cuad --- # DeBERTa v2 XLarge Model fine-tuned with CUAD dataset This model is the fine-tuned version of "DeBERTa v2 XLarge" using CUAD dataset https://huggingface.co/datasets/cuad Link for model checkpoint: https://github.com/TheAtticusProject/cuad For the use of the model with CUAD: https://github.com/marshmellow77/cuad-demo and https://huggingface.co/spaces/akdeniz27/contract-understanding-atticus-dataset-demo
jason9693/SoongsilBERT-base-beep
83bf1d729a5cf0d1e11baf3920bba654e362a186
2022-04-16T14:26:17.000Z
[ "pytorch", "jax", "roberta", "text-classification", "ko", "dataset:kor_hate", "transformers" ]
text-classification
false
jason9693
null
jason9693/SoongsilBERT-base-beep
629
null
transformers
2,125
--- language: ko widget: - text: "응 어쩔티비~" datasets: - kor_hate --- # Finetuning ## Result ### Base Model | | Size | **NSMC**<br/>(acc) | **Naver NER**<br/>(F1) | **PAWS**<br/>(acc) | **KorNLI**<br/>(acc) | **KorSTS**<br/>(spearman) | **Question Pair**<br/>(acc) | **KorQuaD (Dev)**<br/>(EM/F1) | **Korean-Hate-Speech (Dev)**<br/>(F1) | | :-------------------- | :---: | :----------------: | :--------------------: | :----------------: | :------------------: | :-----------------------: | :-------------------------: | :---------------------------: | :-----------------------------------: | | KoBERT | 351M | 89.59 | 87.92 | 81.25 | 79.62 | 81.59 | 94.85 | 51.75 / 79.15 | 66.21 | | XLM-Roberta-Base | 1.03G | 89.03 | 86.65 | 82.80 | 80.23 | 78.45 | 93.80 | 64.70 / 88.94 | 64.06 | | HanBERT | 614M | 90.06 | 87.70 | 82.95 | 80.32 | 82.73 | 94.72 | 78.74 / 92.02 | 68.32 | | KoELECTRA-Base-v3 | 431M | 90.63 | 88.11 | 84.45 | 82.24 | 85.53 | 95.25 | 84.83 / 93.45 | 67.61 | | Soongsil-BERT | 370M | **91.2** | - | - | - | 76 | 94 | - | **69** | ### Small Model | | Size | **NSMC**<br/>(acc) | **Naver NER**<br/>(F1) | **PAWS**<br/>(acc) | **KorNLI**<br/>(acc) | **KorSTS**<br/>(spearman) | **Question Pair**<br/>(acc) | **KorQuaD (Dev)**<br/>(EM/F1) | **Korean-Hate-Speech (Dev)**<br/>(F1) | | :--------------------- | :--: | :----------------: | :--------------------: | :----------------: | :------------------: | :-----------------------: | :-------------------------: | :---------------------------: | :-----------------------------------: | | DistilKoBERT | 108M | 88.60 | 84.65 | 60.50 | 72.00 | 72.59 | 92.48 | 54.40 / 77.97 | 60.72 | | KoELECTRA-Small-v3 | 54M | 89.36 | 85.40 | 77.45 | 78.60 | 80.79 | 94.85 | 82.11 / 91.13 | 63.07 | | Soongsil-BERT | 213M | **90.7** | 84 | 69.1 | 76 | - | 92 | - | **66** | ## Reference - [Transformers Examples](https://github.com/huggingface/transformers/blob/master/examples/README.md) - [NSMC](https://github.com/e9t/nsmc) - [Naver NER Dataset](https://github.com/naver/nlp-challenge) - [PAWS](https://github.com/google-research-datasets/paws) - [KorNLI/KorSTS](https://github.com/kakaobrain/KorNLUDatasets) - [Question Pair](https://github.com/songys/Question_pair) - [KorQuad](https://korquad.github.io/category/1.0_KOR.html) - [Korean Hate Speech](https://github.com/kocohub/korean-hate-speech) - [KoELECTRA](https://github.com/monologg/KoELECTRA) - [KoBERT](https://github.com/SKTBrain/KoBERT) - [HanBERT](https://github.com/tbai2019/HanBert-54k-N) - [HanBert Transformers](https://github.com/monologg/HanBert-Transformers)
textattack/albert-base-v2-MRPC
86655e0ce120f86e1e60ce94a602908bb9a4e128
2020-07-06T16:29:43.000Z
[ "pytorch", "albert", "text-classification", "transformers" ]
text-classification
false
textattack
null
textattack/albert-base-v2-MRPC
628
null
transformers
2,126
## TextAttack Model Card This `albert-base-v2` model was fine-tuned for sequence classification using TextAttack and the glue dataset loaded using the `nlp` library. The model was fine-tuned for 5 epochs with a batch size of 32, a learning rate of 2e-05, and a maximum sequence length of 128. Since this was a classification task, the model was trained with a cross-entropy loss function. The best score the model achieved on this task was 0.8970588235294118, as measured by the eval set accuracy, found after 4 epochs. For more information, check out [TextAttack on Github](https://github.com/QData/TextAttack).
mrm8488/codebert-base-finetuned-stackoverflow-ner
dbffc9f8716da2766cfda31d269e409c49fb54d2
2021-05-20T18:21:42.000Z
[ "pytorch", "jax", "roberta", "token-classification", "transformers", "autotrain_compatible" ]
token-classification
false
mrm8488
null
mrm8488/codebert-base-finetuned-stackoverflow-ner
627
3
transformers
2,127
Entry not found
manishiitg/distilbert-resume-parts-classify
5877484c10f0325f96e699286ada2afe2ee939ad
2020-12-09T13:59:30.000Z
[ "pytorch", "distilbert", "text-classification", "transformers" ]
text-classification
false
manishiitg
null
manishiitg/distilbert-resume-parts-classify
624
1
transformers
2,128
Entry not found
facebook/data2vec-vision-base-ft1k
9c7678bab4dcde1342510d62f201db7f8e98e6ff
2022-05-03T15:08:31.000Z
[ "pytorch", "tf", "data2vec-vision", "image-classification", "dataset:imagenet", "dataset:imagenet-1k", "arxiv:2202.03555", "arxiv:2106.08254", "transformers", "vision", "license:apache-2.0" ]
image-classification
false
facebook
null
facebook/data2vec-vision-base-ft1k
624
null
transformers
2,129
--- license: apache-2.0 tags: - image-classification - vision datasets: - imagenet - imagenet-1k --- # Data2Vec-Vision (base-sized model, fine-tuned on ImageNet-1k) BEiT model pre-trained in a self-supervised fashion and fine-tuned on ImageNet-1k (1,2 million images, 1000 classes) at resolution 224x224. It was introduced in the paper [data2vec: A General Framework for Self-supervised Learning in Speech, Vision and Language](https://arxiv.org/abs/2202.03555) by Alexei Baevski, Wei-Ning Hsu, Qiantong Xu, Arun Babu, Jiatao Gu, Michael Auli and first released in [this repository](https://github.com/facebookresearch/data2vec_vision/tree/main/beit). Disclaimer: The team releasing Facebook team did not write a model card for this model so this model card has been written by the Hugging Face team. ## Pre-Training method ![model image](https://raw.githubusercontent.com/patrickvonplaten/scientific_images/master/data2vec.png) For more information, please take a look at the [official paper](https://arxiv.org/abs/2202.03555). ## Abstract *While the general idea of self-supervised learning is identical across modalities, the actual algorithms and objectives differ widely because they were developed with a single modality in mind. To get us closer to general self-supervised learning, we present data2vec, a framework that uses the same learning method for either speech, NLP or computer vision. The core idea is to predict latent representations of the full input data based on a masked view of the input in a selfdistillation setup using a standard Transformer architecture. Instead of predicting modality-specific targets such as words, visual tokens or units of human speech which are local in nature, data2vec predicts contextualized latent representations that contain information from the entire input. Experiments on the major benchmarks of speech recognition, image classification, and natural language understanding demonstrate a new state of the art or competitive performance to predominant approaches.* ## Intended uses & limitations You can use the raw model for image classification. See the [model hub](https://huggingface.co/models?search=data2vec-vision) to look for fine-tuned versions on a task that interests you. ### How to use Here is how to use this model to classify an image of the COCO 2017 dataset into one of the 1,000 ImageNet classes: ```python from transformers import BeitFeatureExtractor, Data2VecVisionForImageClassification from PIL import Image import requests url = 'http://images.cocodataset.org/val2017/000000039769.jpg' image = Image.open(requests.get(url, stream=True).raw) feature_extractor = BeitFeatureExtractor.from_pretrained('facebook/data2vec-vision-base-ft1k') model = Data2VecVisionForImageClassification.from_pretrained('facebook/data2vec-vision-base-ft1k') inputs = feature_extractor(images=image, return_tensors="pt") outputs = model(**inputs) logits = outputs.logits # model predicts one of the 1000 ImageNet classes predicted_class_idx = logits.argmax(-1).item() print("Predicted class:", model.config.id2label[predicted_class_idx]) ``` Currently, both the feature extractor and model support PyTorch. ## Training data The BEiT model was pretrained and fine-tuned on [ImageNet-1k](http://www.image-net.org/), a dataset consisting of 1,2 million images and 1k classes. ## Training procedure ### Preprocessing The exact details of preprocessing of images during training/validation can be found [here](https://github.com/microsoft/unilm/blob/master/beit/datasets.py). Images are resized/rescaled to the same resolution (224x224) and normalized across the RGB channels with mean (0.5, 0.5, 0.5) and standard deviation (0.5, 0.5, 0.5). ### Pretraining For all pre-training related hyperparameters, we refer to the [original paper](https://arxiv.org/abs/2106.08254) and the [original codebase](https://github.com/facebookresearch/data2vec_vision/tree/main/beit) ## Evaluation results For evaluation results on several image classification benchmarks, we refer to tables 1 of the original paper. Note that for fine-tuning, the best results are obtained with a higher resolution. Of course, increasing the model size will result in better performance. We evaluated the model on `ImageNet1K` and got top-1 accuracy = **83.97** while in the original paper it was reported top-1 accuracy = 84.2. If you want to reproduce our evaluation process you can use [This Colab Notebook](https://colab.research.google.com/drive/1Tse8Rfv-QhapMEMzauxUqnAQyXUgnTLK?usp=sharing) ### BibTeX entry and citation info ```bibtex @misc{https://doi.org/10.48550/arxiv.2202.03555, doi = {10.48550/ARXIV.2202.03555}, url = {https://arxiv.org/abs/2202.03555}, author = {Baevski, Alexei and Hsu, Wei-Ning and Xu, Qiantong and Babu, Arun and Gu, Jiatao and Auli, Michael}, keywords = {Machine Learning (cs.LG), FOS: Computer and information sciences, FOS: Computer and information sciences}, title = {data2vec: A General Framework for Self-supervised Learning in Speech, Vision and Language}, publisher = {arXiv}, year = {2022}, copyright = {arXiv.org perpetual, non-exclusive license} } ```
clue/roberta_chinese_large
e1ced8cb9dadb0c677cefd9e42b770dc863e78ea
2021-05-20T15:28:53.000Z
[ "pytorch", "jax", "roberta", "zh", "transformers" ]
null
false
clue
null
clue/roberta_chinese_large
622
null
transformers
2,130
--- language: zh --- ## roberta_chinese_large ### Overview **Language model:** roberta-large **Model size:** 1.2G **Language:** Chinese **Training data:** [CLUECorpusSmall](https://github.com/CLUEbenchmark/CLUECorpus2020) **Eval data:** [CLUE dataset](https://github.com/CLUEbenchmark/CLUE) ### Results For results on downstream tasks like text classification, please refer to [this repository](https://github.com/CLUEbenchmark/CLUE). ### Usage **NOTE:** You have to call **BertTokenizer** instead of RobertaTokenizer !!! ``` import torch from transformers import BertTokenizer, BertModel tokenizer = BertTokenizer.from_pretrained("clue/roberta_chinese_large") roberta = BertModel.from_pretrained("clue/roberta_chinese_large") ``` ### About CLUE benchmark Organization of Language Understanding Evaluation benchmark for Chinese: tasks & datasets, baselines, pre-trained Chinese models, corpus and leaderboard. Github: https://github.com/CLUEbenchmark Website: https://www.cluebenchmarks.com/
svalabs/gbert-large-zeroshot-nli
d106a0557ab5a76e762f7fcb8524cb61710a0ba1
2021-12-21T15:07:03.000Z
[ "pytorch", "bert", "text-classification", "German", "transformers", "nli", "de", "zero-shot-classification" ]
zero-shot-classification
false
svalabs
null
svalabs/gbert-large-zeroshot-nli
620
4
transformers
2,131
--- language: German tags: - text-classification - pytorch - nli - de pipeline_tag: zero-shot-classification widget: - text: "Ich habe ein Problem mit meinem Iphone das so schnell wie möglich gelöst werden muss." candidate_labels: "Computer, Handy, Tablet, dringend, nicht dringend" hypothesis_template: "In diesem Satz geht es um das Thema {}." --- # SVALabs - Gbert Large Zeroshot Nli In this repository, we present our German zeroshot classification model. This model was trained on the basis of the German BERT large model from [deepset.ai](https://huggingface.co/deepset/gbert-large) and finetuned for natural language inference based on 847.862 machine-translated nli sentence pairs, using the [mnli](https://huggingface.co/datasets/multi_nli), [anli](https://huggingface.co/datasets/anli) and [snli](https://huggingface.co/datasets/snli) datasets. For this purpose, we translated the sentence pairs in these datasets to German. If you are a German speaker you may also have a look at our [Blog post](https://focus.sva.de/zeroshot-klassifikation/) about this model and about Zeroshot Classification. ### Model Details | | Description or Link | |---|---| |**Base model** | [```gbert-large```](https://huggingface.co/deepset/gbert-large) | |**Finetuning task**| Text Pair Classification / Natural Language Inference | |**Source datasets**| [```mnli```](https://huggingface.co/datasets/multi_nli); [```anli```](https://huggingface.co/datasets/anli); [```snli```](https://huggingface.co/datasets/snli) | ### Performance We evaluated our model for the nli task using the TEST set of the German part of the [xnli](https://huggingface.co/datasets/xnli) dataset. XNLI TEST-Set Accuracy: 85.6% ### Zeroshot Text Classification Task Benchmark We further tested our model for a zeroshot text classification task using a part of the [10kGNAD Dataset](https://tblock.github.io/10kGNAD/). Specifically, we used all articles that were labeled "Kultur", "Sport", "Web", "Wirtschaft" and "Wissenschaft". The next table shows the results as well as a comparison with other German language and multilanguage zeroshot options performing the same task: | Model | Accuracy | |:-------------------:|:------:| | Svalabs/gbert-large-zeroshot-nli | 0.81 | | Sahajtomar/German_Zeroshot | 0.76 | | Symanto/xlm-roberta-base-snli-mnli-anli-xnli | 0.16 | | Deepset/gbert-base | 0.65 | ### How to use The simplest way to use the model is the huggingface transformers pipeline tool. Just initialize the pipeline specifying the task as "zero-shot-classification" and select "svalabs/gbert-large-zeroshot-nli" as model. The model requires you to specify labels, a sequence (or list of sequences) to classify and a hypothesis template. In our tests, if the labels comprise only single words, "In diesem Satz geht es um das Thema {}" performed the best. However, for multiple words, especially when they combine nouns and verbs, simple hypothesis such as "Weil {}" or "Daher {}" may work better. Here is an example of how to use the model: ```python from transformers import pipeline zershot_pipeline = pipeline("zero-shot-classification", model="svalabs/gbert-large-zeroshot-nli") sequence = "Ich habe ein Problem mit meinem Iphone das so schnell wie möglich gelöst werden muss" labels = ["Computer", "Handy", "Tablet", "dringend", "nicht dringend"] hypothesis_template = "In diesem Satz geht es um das Thema {}." zershot_pipeline(sequence, labels, hypothesis_template=hypothesis_template) ``` ### Contact - Daniel Ehnes, [email protected] - Baran Avinc, [email protected]
Irina/cyoa_GPT3Medium
762fcb11b322c82b0c1d1a552b07a4f69a4869b5
2021-11-09T00:14:52.000Z
[ "pytorch", "gpt2", "text-generation", "transformers" ]
text-generation
false
Irina
null
Irina/cyoa_GPT3Medium
619
null
transformers
2,132
Entry not found
asafaya/hubert-large-arabic
a379c0291c1149cb694ccfe9d976dd23c9bfadb6
2022-02-08T14:04:07.000Z
[ "pytorch", "hubert", "feature-extraction", "ar", "arxiv:2106.07447", "transformers", "speech", "audio", "license:cc-by-nc-4.0" ]
feature-extraction
false
asafaya
null
asafaya/hubert-large-arabic
619
null
transformers
2,133
--- language: ar tags: - speech - audio license: cc-by-nc-4.0 --- # Arabic Hubert-Large This model was pre-trained on 2,000 hours of 16kHz sampled Arabic speech audio. When using the model make sure that your speech input is also sampled at 16Khz. [Paper](https://arxiv.org/abs/2106.07447). Training of this mode was performed using [fairseq](https://github.com/pytorch/fairseq). Tensorboard logs of the training can be found [here](https://tensorboard.dev/experiment/AWc8Zj8kQ8KQgL0ytRsMFA/#scalars) **Note**: This model does not have a tokenizer as it was pretrained on audio alone. In order to use this model **speech recognition**, a tokenizer should be created and the model should be fine-tuned on labeled text data. # Usage See [this blog](https://huggingface.co/blog/fine-tune-wav2vec2-english) for more information on how to fine-tune the model. Note that the class `Wav2Vec2ForCTC` has to be replaced by `HubertForCTC`. # License This work is licensed under CC BY-NC-4.0. # Acknowledgments Model pre-training and data processing for in this work partially performed at [KUIS AI Center](ai.ku.edu.tr/) Cluster, and TUBITAK ULAKBIM Cluster ([TRUBA](https://www.truba.gov.tr/) resources).
assemblyai/bert-large-uncased-sst2
c062c23b049fad7e1bcda360ca2f77b9d61530e6
2021-06-14T22:04:39.000Z
[ "pytorch", "bert", "text-classification", "arxiv:1810.04805", "transformers" ]
text-classification
false
assemblyai
null
assemblyai/bert-large-uncased-sst2
619
null
transformers
2,134
# BERT-Large-Uncased for Sentiment Analysis This model is a fine-tuned version of [bert-large-uncased](https://huggingface.co/bert-large-uncased) originally released in ["BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding"](https://arxiv.org/abs/1810.04805) and trained on the [Stanford Sentiment Treebank v2 (SST2)](https://nlp.stanford.edu/sentiment/); part of the [General Language Understanding Evaluation (GLUE)](https://gluebenchmark.com) benchmark. This model was fine-tuned by the team at [AssemblyAI](https://www.assemblyai.com) and is released with the [corresponding blog post](). ## Usage To download and utilize this model for sentiment analysis please execute the following: ```python import torch.nn.functional as F from transformers import AutoTokenizer, AutoModelForSequenceClassification tokenizer = AutoTokenizer.from_pretrained("assemblyai/bert-large-uncased-sst2") model = AutoModelForSequenceClassification.from_pretrained("assemblyai/bert-large-uncased-sst2") tokenized_segments = tokenizer(["AssemblyAI is the best speech-to-text API for modern developers with performance being second to none!"], return_tensors="pt", padding=True, truncation=True) tokenized_segments_input_ids, tokenized_segments_attention_mask = tokenized_segments.input_ids, tokenized_segments.attention_mask model_predictions = F.softmax(model(input_ids=tokenized_segments_input_ids, attention_mask=tokenized_segments_attention_mask)['logits'], dim=1) print("Positive probability: "+str(model_predictions[0][1].item()*100)+"%") print("Negative probability: "+str(model_predictions[0][0].item()*100)+"%") ``` For questions about how to use this model feel free to contact the team at [AssemblyAI](https://www.assemblyai.com)!
Helsinki-NLP/opus-mt-en-sk
280452f8648f491943adba0bab9c64886fbdf053
2021-09-09T21:39:03.000Z
[ "pytorch", "marian", "text2text-generation", "en", "sk", "transformers", "translation", "license:apache-2.0", "autotrain_compatible" ]
translation
false
Helsinki-NLP
null
Helsinki-NLP/opus-mt-en-sk
615
null
transformers
2,135
--- tags: - translation license: apache-2.0 --- ### opus-mt-en-sk * source languages: en * target languages: sk * OPUS readme: [en-sk](https://github.com/Helsinki-NLP/OPUS-MT-train/blob/master/models/en-sk/README.md) * dataset: opus * model: transformer-align * pre-processing: normalization + SentencePiece * download original weights: [opus-2020-01-08.zip](https://object.pouta.csc.fi/OPUS-MT-models/en-sk/opus-2020-01-08.zip) * test set translations: [opus-2020-01-08.test.txt](https://object.pouta.csc.fi/OPUS-MT-models/en-sk/opus-2020-01-08.test.txt) * test set scores: [opus-2020-01-08.eval.txt](https://object.pouta.csc.fi/OPUS-MT-models/en-sk/opus-2020-01-08.eval.txt) ## Benchmarks | testset | BLEU | chr-F | |-----------------------|-------|-------| | JW300.en.sk | 36.8 | 0.578 |
JDBN/t5-base-fr-qg-fquad
824375c05efc88b272b8b1af32b481cdbfd97a53
2021-06-23T02:26:52.000Z
[ "pytorch", "jax", "t5", "text2text-generation", "fr", "dataset:fquad", "dataset:piaf", "arxiv:1910.10683", "arxiv:2002.06071", "transformers", "question-generation", "seq2seq", "autotrain_compatible" ]
text2text-generation
false
JDBN
null
JDBN/t5-base-fr-qg-fquad
615
null
transformers
2,136
--- language: fr widget: - text: "generate question: Barack Hussein Obama, né le 4 aout 1961, est un homme politique américain et avocat. Il a été élu <hl> en 2009 <hl> pour devenir le 44ème président des Etats-Unis d'Amérique. </s>" - text: "question: Quand Barack Obama a t'il été élu président? context: Barack Hussein Obama, né le 4 aout 1961, est un homme politique américain et avocat. Il a été élu en 2009 pour devenir le 44ème président des Etats-Unis d'Amérique. </s>" tags: - pytorch - t5 - question-generation - seq2seq datasets: - fquad - piaf --- # T5 Question Generation and Question Answering ## Model description This model is a T5 Transformers model (airklizz/t5-base-multi-fr-wiki-news) that was fine-tuned in french on 3 different tasks * question generation * question answering * answer extraction It obtains quite good results on FQuAD validation dataset. ## Intended uses & limitations This model functions for the 3 tasks mentionned earlier and was not tested on other tasks. ```python from transformers import T5ForConditionalGeneration, T5Tokenizer model = T5ForConditionalGeneration.from_pretrained("JDBN/t5-base-fr-qg-fquad") tokenizer = T5Tokenizer.from_pretrained("JDBN/t5-base-fr-qg-fquad") ``` ## Training data The initial model used was https://huggingface.co/airKlizz/t5-base-multi-fr-wiki-news. This model was finetuned on a dataset composed of FQuAD and PIAF on the 3 tasks mentioned previously. The data were preprocessed like this * question generation: "generate question: Barack Hussein Obama, né le 4 aout 1961, est un homme politique américain et avocat. Il a été élu <hl> en 2009 <hl> pour devenir le 44ème président des Etats-Unis d'Amérique." * question answering: "question: Quand Barack Hussein Obamaa-t-il été élu président des Etats-Unis d’Amérique? context: Barack Hussein Obama, né le 4 aout 1961, est un homme politique américain et avocat. Il a été élu en 2009 pour devenir le 44ème président des Etats-Unis d’Amérique." * answer extraction: "extract_answers: Barack Hussein Obama, né le 4 aout 1961, est un homme politique américain et avocat. <hl> Il a été élu en 2009 pour devenir le 44ème président des Etats-Unis d’Amérique <hl>." The preprocessing we used was implemented in https://github.com/patil-suraj/question_generation ## Eval results #### On FQuAD validation set | BLEU_1 | BLEU_2 | BLEU_3 | BLEU_4 | METEOR | ROUGE_L | CIDEr | |--------|--------|--------|--------|--------|---------|-------| | 0.290 | 0.203 | 0.149 | 0.111 | 0.197 | 0.284 | 1.038 | #### Question Answering metrics For these metrics, the performance of this question answering model (https://huggingface.co/illuin/camembert-base-fquad) on FQuAD original question and on T5 generated questions are compared. | Questions | Exact Match | F1 Score | |------------------|--------|--------| |Original FQuAD | 54.015 | 77.466 | |Generated | 45.765 | 67.306 | ### BibTeX entry and citation info ```bibtex @misc{githubPatil, author = {Patil Suraj}, title = {question generation GitHub repository}, year = {2020}, howpublished={\url{https://github.com/patil-suraj/question_generation}} } @article{T5, title={Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer}, author={Colin Raffel and Noam Shazeer and Adam Roberts and Katherine Lee and Sharan Narang and Michael Matena and Yanqi Zhou and Wei Li and Peter J. Liu}, year={2019}, eprint={1910.10683}, archivePrefix={arXiv}, primaryClass={cs.LG} } @misc{dhoffschmidt2020fquad, title={FQuAD: French Question Answering Dataset}, author={Martin d'Hoffschmidt and Wacim Belblidia and Tom Brendlé and Quentin Heinrich and Maxime Vidal}, year={2020}, eprint={2002.06071}, archivePrefix={arXiv}, primaryClass={cs.CL} } ```
cahya/xlm-roberta-base-indonesian-NER
32e9f2c521b9c891b01ee6401460a428b678c65d
2020-09-23T15:55:35.000Z
[ "pytorch", "xlm-roberta", "token-classification", "transformers", "autotrain_compatible" ]
token-classification
false
cahya
null
cahya/xlm-roberta-base-indonesian-NER
614
null
transformers
2,137
Entry not found
cross-encoder/nli-MiniLM2-L6-H768
72873be33d4058aac21d3c9e86036a8901636537
2021-08-05T08:40:39.000Z
[ "pytorch", "roberta", "text-classification", "en", "dataset:multi_nli", "dataset:snli", "transformers", "MiniLMv2", "license:apache-2.0", "zero-shot-classification" ]
zero-shot-classification
false
cross-encoder
null
cross-encoder/nli-MiniLM2-L6-H768
613
null
transformers
2,138
--- language: en pipeline_tag: zero-shot-classification license: apache-2.0 tags: - MiniLMv2 datasets: - multi_nli - snli metrics: - accuracy --- # Cross-Encoder for Natural Language Inference This model was trained using [SentenceTransformers](https://sbert.net) [Cross-Encoder](https://www.sbert.net/examples/applications/cross-encoder/README.html) class. ## Training Data The model was trained on the [SNLI](https://nlp.stanford.edu/projects/snli/) and [MultiNLI](https://cims.nyu.edu/~sbowman/multinli/) datasets. For a given sentence pair, it will output three scores corresponding to the labels: contradiction, entailment, neutral. ## Performance For evaluation results, see [SBERT.net - Pretrained Cross-Encoder](https://www.sbert.net/docs/pretrained_cross-encoders.html#nli). ## Usage Pre-trained models can be used like this: ```python from sentence_transformers import CrossEncoder model = CrossEncoder('cross-encoder/nli-MiniLM2-L6-H768') scores = model.predict([('A man is eating pizza', 'A man eats something'), ('A black race car starts up in front of a crowd of people.', 'A man is driving down a lonely road.')]) #Convert scores to labels label_mapping = ['contradiction', 'entailment', 'neutral'] labels = [label_mapping[score_max] for score_max in scores.argmax(axis=1)] ``` ## Usage with Transformers AutoModel You can use the model also directly with Transformers library (without SentenceTransformers library): ```python from transformers import AutoTokenizer, AutoModelForSequenceClassification import torch model = AutoModelForSequenceClassification.from_pretrained('cross-encoder/nli-MiniLM2-L6-H768') tokenizer = AutoTokenizer.from_pretrained('cross-encoder/nli-MiniLM2-L6-H768') features = tokenizer(['A man is eating pizza', 'A black race car starts up in front of a crowd of people.'], ['A man eats something', 'A man is driving down a lonely road.'], padding=True, truncation=True, return_tensors="pt") model.eval() with torch.no_grad(): scores = model(**features).logits label_mapping = ['contradiction', 'entailment', 'neutral'] labels = [label_mapping[score_max] for score_max in scores.argmax(dim=1)] print(labels) ``` ## Zero-Shot Classification This model can also be used for zero-shot-classification: ```python from transformers import pipeline classifier = pipeline("zero-shot-classification", model='cross-encoder/nli-MiniLM2-L6-H768') sent = "Apple just announced the newest iPhone X" candidate_labels = ["technology", "sports", "politics"] res = classifier(sent, candidate_labels) print(res) ```
google/pegasus-billsum
6866f3587d8fcaf4eca812eba871f1afde20ca72
2020-10-22T16:33:23.000Z
[ "pytorch", "pegasus", "text2text-generation", "en", "arxiv:1912.08777", "transformers", "summarization", "autotrain_compatible" ]
summarization
false
google
null
google/pegasus-billsum
613
2
transformers
2,139
--- language: en tags: - summarization --- ### Pegasus Models See Docs: [here](https://huggingface.co/transformers/master/model_doc/pegasus.html) Original TF 1 code [here](https://github.com/google-research/pegasus) Authors: Jingqing Zhang, Yao Zhao, Mohammad Saleh and Peter J. Liu on Dec 18, 2019 Maintained by: [@sshleifer](https://twitter.com/sam_shleifer) Task: Summarization The following is copied from the authors' README. # Mixed & Stochastic Checkpoints We train a pegasus model with sampled gap sentence ratios on both C4 and HugeNews, and stochastically sample important sentences. The updated the results are reported in this table. | dataset | C4 | HugeNews | Mixed & Stochastic| | ---- | ---- | ---- | ----| | xsum | 45.20/22.06/36.99 | 47.21/24.56/39.25 | 47.60/24.83/39.64| | cnn_dailymail | 43.90/21.20/40.76 | 44.17/21.47/41.11 | 44.16/21.56/41.30| | newsroom | 45.07/33.39/41.28 | 45.15/33.51/41.33 | 45.98/34.20/42.18| | multi_news | 46.74/17.95/24.26 | 47.52/18.72/24.91 | 47.65/18.75/24.95| | gigaword | 38.75/19.96/36.14 | 39.12/19.86/36.24 | 39.65/20.47/36.76| | wikihow | 43.07/19.70/34.79 | 41.35/18.51/33.42 | 46.39/22.12/38.41 *| | reddit_tifu | 26.54/8.94/21.64 | 26.63/9.01/21.60 | 27.99/9.81/22.94| | big_patent | 53.63/33.16/42.25 | 53.41/32.89/42.07 | 52.29/33.08/41.66 *| | arxiv | 44.70/17.27/25.80 | 44.67/17.18/25.73 | 44.21/16.95/25.67| | pubmed | 45.49/19.90/27.69 | 45.09/19.56/27.42 | 45.97/20.15/28.25| | aeslc | 37.69/21.85/36.84 | 37.40/21.22/36.45 | 37.68/21.25/36.51| | billsum | 57.20/39.56/45.80 | 57.31/40.19/45.82 | 59.67/41.58/47.59| The "Mixed & Stochastic" model has the following changes: - trained on both C4 and HugeNews (dataset mixture is weighted by their number of examples). - trained for 1.5M instead of 500k (we observe slower convergence on pretraining perplexity). - the model uniformly sample a gap sentence ratio between 15% and 45%. - importance sentences are sampled using a 20% uniform noise to importance scores. - the sentencepiece tokenizer is updated to be able to encode newline character. (*) the numbers of wikihow and big_patent datasets are not comparable because of change in tokenization and data: - wikihow dataset contains newline characters which is useful for paragraph segmentation, the C4 and HugeNews model's sentencepiece tokenizer doesn't encode newline and loose this information. - we update the BigPatent dataset to preserve casing, some format cleanings are also changed, please refer to change in TFDS. The "Mixed & Stochastic" model has the following changes (from pegasus-large in the paper): trained on both C4 and HugeNews (dataset mixture is weighted by their number of examples). trained for 1.5M instead of 500k (we observe slower convergence on pretraining perplexity). the model uniformly sample a gap sentence ratio between 15% and 45%. importance sentences are sampled using a 20% uniform noise to importance scores. the sentencepiece tokenizer is updated to be able to encode newline character. Citation ``` @misc{zhang2019pegasus, title={PEGASUS: Pre-training with Extracted Gap-sentences for Abstractive Summarization}, author={Jingqing Zhang and Yao Zhao and Mohammad Saleh and Peter J. Liu}, year={2019}, eprint={1912.08777}, archivePrefix={arXiv}, primaryClass={cs.CL} } ```
GanjinZero/biobart-base
ef5abe2f6df026915823c1b06474da4ee5ad9ff8
2022-04-25T02:17:13.000Z
[ "pytorch", "bart", "text2text-generation", "en", "arxiv:2204.03905", "transformers", "biobart", "biomedical", "license:apache-2.0", "autotrain_compatible" ]
text2text-generation
false
GanjinZero
null
GanjinZero/biobart-base
613
1
transformers
2,140
--- language: - en license: apache-2.0 tags: - bart - biobart - biomedical inference: true widget: - text: "Influenza is a <mask> disease." - type: "text-generation" --- Paper: [BioBART: Pretraining and Evaluation of A Biomedical Generative Language Model](https://arxiv.org/pdf/2204.03905.pdf) ``` @misc{BioBART, title={BioBART: Pretraining and Evaluation of A Biomedical Generative Language Model}, author={Hongyi Yuan and Zheng Yuan and Ruyi Gan and Jiaxing Zhang and Yutao Xie and Sheng Yu}, year={2022}, eprint={2204.03905}, archivePrefix={arXiv} } ```
Nakul24/YC_Bot
8181a7985d79549e5f0e404505620f674ffd7355
2022-07-05T16:23:59.000Z
[ "pytorch", "gpt2", "text-generation", "transformers", "conversational" ]
conversational
false
Nakul24
null
Nakul24/YC_Bot
613
1
transformers
2,141
--- tags: - conversational ---
sentence-transformers/bert-base-nli-cls-token
e843bdcd4b124d765c5a2d100118212610719537
2022-06-15T23:01:27.000Z
[ "pytorch", "tf", "jax", "bert", "feature-extraction", "arxiv:1908.10084", "sentence-transformers", "sentence-similarity", "transformers", "license:apache-2.0" ]
sentence-similarity
false
sentence-transformers
null
sentence-transformers/bert-base-nli-cls-token
611
null
sentence-transformers
2,142
--- pipeline_tag: sentence-similarity tags: - sentence-transformers - feature-extraction - sentence-similarity - transformers license: apache-2.0 --- # bert-base-nli-cls-token **⚠️ This model is deprecated. Please don't use it as it produces sentence embeddings of low quality. You can find recommended sentence embedding models here: [SBERT.net - Pretrained Models](https://www.sbert.net/docs/pretrained_models.html)** This is a [sentence-transformers](https://www.SBERT.net) model: It maps sentences & paragraphs to a 768 dimensional dense vector space and can be used for tasks like clustering or semantic search. ## Usage (Sentence-Transformers) Using this model becomes easy when you have [sentence-transformers](https://www.SBERT.net) installed: ``` pip install -U sentence-transformers ``` Then you can use the model like this: ```python from sentence_transformers import SentenceTransformer sentences = ["This is an example sentence", "Each sentence is converted"] model = SentenceTransformer('sentence-transformers/bert-base-nli-cls-token') embeddings = model.encode(sentences) print(embeddings) ``` ## Usage (HuggingFace Transformers) Without [sentence-transformers](https://www.SBERT.net), you can use the model like this: First, you pass your input through the transformer model, then you have to apply the right pooling-operation on-top of the contextualized word embeddings. ```python from transformers import AutoTokenizer, AutoModel import torch def cls_pooling(model_output, attention_mask): return model_output[0][:,0] # Sentences we want sentence embeddings for sentences = ['This is an example sentence', 'Each sentence is converted'] # Load model from HuggingFace Hub tokenizer = AutoTokenizer.from_pretrained('sentence-transformers/bert-base-nli-cls-token') model = AutoModel.from_pretrained('sentence-transformers/bert-base-nli-cls-token') # Tokenize sentences encoded_input = tokenizer(sentences, padding=True, truncation=True, return_tensors='pt') # Compute token embeddings with torch.no_grad(): model_output = model(**encoded_input) # Perform pooling. In this case, max pooling. sentence_embeddings = cls_pooling(model_output, encoded_input['attention_mask']) print("Sentence embeddings:") print(sentence_embeddings) ``` ## Evaluation Results For an automated evaluation of this model, see the *Sentence Embeddings Benchmark*: [https://seb.sbert.net](https://seb.sbert.net?model_name=sentence-transformers/bert-base-nli-cls-token) ## Full Model Architecture ``` SentenceTransformer( (0): Transformer({'max_seq_length': 128, 'do_lower_case': False}) with Transformer model: BertModel (1): Pooling({'word_embedding_dimension': 768, 'pooling_mode_cls_token': True, 'pooling_mode_mean_tokens': False, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False}) ) ``` ## Citing & Authors This model was trained by [sentence-transformers](https://www.sbert.net/). If you find this model helpful, feel free to cite our publication [Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks](https://arxiv.org/abs/1908.10084): ```bibtex @inproceedings{reimers-2019-sentence-bert, title = "Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks", author = "Reimers, Nils and Gurevych, Iryna", booktitle = "Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing", month = "11", year = "2019", publisher = "Association for Computational Linguistics", url = "http://arxiv.org/abs/1908.10084", } ```
ckiplab/albert-base-chinese-pos
aa611efbdd4bfef7c33b0594d0cee70575fb5f69
2022-05-10T03:28:09.000Z
[ "pytorch", "albert", "token-classification", "zh", "transformers", "license:gpl-3.0", "autotrain_compatible" ]
token-classification
false
ckiplab
null
ckiplab/albert-base-chinese-pos
609
null
transformers
2,143
--- language: - zh thumbnail: https://ckip.iis.sinica.edu.tw/files/ckip_logo.png tags: - pytorch - token-classification - albert - zh license: gpl-3.0 --- # CKIP ALBERT Base Chinese This project provides traditional Chinese transformers models (including ALBERT, BERT, GPT2) and NLP tools (including word segmentation, part-of-speech tagging, named entity recognition). 這個專案提供了繁體中文的 transformers 模型（包含 ALBERT、BERT、GPT2）及自然語言處理工具（包含斷詞、詞性標記、實體辨識）。 ## Homepage - https://github.com/ckiplab/ckip-transformers ## Contributers - [Mu Yang](https://muyang.pro) at [CKIP](https://ckip.iis.sinica.edu.tw) (Author & Maintainer) ## Usage Please use BertTokenizerFast as tokenizer instead of AutoTokenizer. 請使用 BertTokenizerFast 而非 AutoTokenizer。 ``` from transformers import ( BertTokenizerFast, AutoModel, ) tokenizer = BertTokenizerFast.from_pretrained('bert-base-chinese') model = AutoModel.from_pretrained('ckiplab/albert-base-chinese-pos') ``` For full usage and more information, please refer to https://github.com/ckiplab/ckip-transformers. 有關完整使用方法及其他資訊，請參見 https://github.com/ckiplab/ckip-transformers 。
symanto/xlm-roberta-base-snli-mnli-anli-xnli
f3bad0b1d5570ea4e218fd8a581fe1e5928cef9e
2021-09-30T12:38:34.000Z
[ "pytorch", "xlm-roberta", "text-classification", "ar", "bg", "de", "el", "en", "es", "fr", "ru", "th", "tr", "ur", "vn", "zh", "dataset:SNLI", "dataset:MNLI", "dataset:ANLI", "dataset:XNLI", "transformers", "zero-shot-classification" ]
text-classification
false
symanto
null
symanto/xlm-roberta-base-snli-mnli-anli-xnli
609
3
transformers
2,144
--- language: - ar - bg - de - el - en - es - fr - ru - th - tr - ur - vn - zh datasets: - SNLI - MNLI - ANLI - XNLI tags: - zero-shot-classification --- A cross-attention NLI model trained for zero-shot and few-shot text classification. The base model is [xlm-roberta-base](https://huggingface.co/xlm-roberta-base), trained with the code from [here](https://github.com/facebookresearch/anli); on [SNLI](https://nlp.stanford.edu/projects/snli/), [MNLI](https://cims.nyu.edu/~sbowman/multinli/), [ANLI](https://github.com/facebookresearch/anli) and [XNLI](https://github.com/facebookresearch/XNLI). Usage: ```python from transformers import AutoModelForSequenceClassification, AutoTokenizer import torch import numpy as np model = AutoModelForSequenceClassification.from_pretrained("symanto/xlm-roberta-base-snli-mnli-anli-xnli") tokenizer = AutoTokenizer.from_pretrained("symanto/xlm-roberta-base-snli-mnli-anli-xnli") input_pairs = [ ("I like this pizza.", "The sentence is positive."), ("I like this pizza.", "The sentence is negative."), ("I mag diese Pizza.", "Der Satz ist positiv."), ("I mag diese Pizza.", "Der Satz ist negativ."), ("Me gusta esta pizza.", "Esta frase es positivo."), ("Me gusta esta pizza.", "Esta frase es negativo."), ] inputs = tokenizer(input_pairs, truncation="only_first", return_tensors="pt", padding=True) logits = model(**inputs).logits probs = torch.softmax(logits, dim=1) probs = probs[..., [0]].tolist() print("probs", probs) np.testing.assert_almost_equal(probs, [[0.83], [0.04], [1.00], [0.00], [1.00], [0.00]], decimal=2) ```
efederici/sentence-bert-base
42925afbeb54e2939bc3e47ee57749cbf0fb722d
2022-07-06T07:34:00.000Z
[ "pytorch", "bert", "feature-extraction", "it", "dataset:stsb_multi_mt", "sentence-transformers", "sentence-similarity", "transformers" ]
sentence-similarity
false
efederici
null
efederici/sentence-bert-base
609
2
sentence-transformers
2,145
--- pipeline_tag: sentence-similarity language: - it datasets: - stsb_multi_mt tags: - sentence-transformers - feature-extraction - sentence-similarity - transformers --- # sentence-bert-base This is a [sentence-transformers](https://www.SBERT.net) model: It maps sentences & paragraphs to a 768 dimensional dense vector space and can be used for tasks like clustering or semantic search. It was trained on [stsb](https://huggingface.co/datasets/stsb_multi_mt/viewer/it/train). <!--- Describe your model here --> ## Usage (Sentence-Transformers) Using this model becomes easy when you have [sentence-transformers](https://www.SBERT.net) installed: ``` pip install -U sentence-transformers ``` Then you can use the model like this: ```python from sentence_transformers import SentenceTransformer sentences = ["Questo è un esempio di frase", "Questo è un ulteriore esempio"] model = SentenceTransformer('efederici/sentence-bert-base') embeddings = model.encode(sentences) print(embeddings) ``` ## Usage (HuggingFace Transformers) Without [sentence-transformers](https://www.SBERT.net), you can use the model like this: First, you pass your input through the transformer model, then you have to apply the right pooling-operation on-top of the contextualized word embeddings. ```python from transformers import AutoTokenizer, AutoModel import torch #Mean Pooling - Take attention mask into account for correct averaging def mean_pooling(model_output, attention_mask): token_embeddings = model_output[0] #First element of model_output contains all token embeddings input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float() return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9) # Sentences we want sentence embeddings for sentences = ["Questo è un esempio di frase", "Questo è un ulteriore esempio"] # Load model from HuggingFace Hub tokenizer = AutoTokenizer.from_pretrained('efederici/sentence-bert-base') model = AutoModel.from_pretrained('efederici/sentence-bert-base') # Tokenize sentences encoded_input = tokenizer(sentences, padding=True, truncation=True, return_tensors='pt') # Compute token embeddings with torch.no_grad(): model_output = model(**encoded_input) # Perform pooling. In this case, mean pooling. sentence_embeddings = mean_pooling(model_output, encoded_input['attention_mask']) print("Sentence embeddings:") print(sentence_embeddings) ``` ## Evaluation Results The performance is measured using Pearson and Spearman correlation: - On dev | Model | Pearson correlation | Spearman correlation | | ------------- | ------------- | ------------- | | [efederici/sentence-BERT-IT-base](https://huggingface.co/dangvantuan/sentence-camembert-large)| 72.6 | 72.5 | - On test | Model | Pearson correlation | Spearman correlation | | ------------- | ------------- | ------------- | | [efederici/sentence-BERT-IT-base](https://huggingface.co/dangvantuan/sentence-camembert-large)| 69.0 | 70.0 | ## Full Model Architecture ``` SentenceTransformer( (0): Transformer({'max_seq_length': 512, 'do_lower_case': False}) with Transformer model: BertModel (1): Pooling({'word_embedding_dimension': 768, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False}) ) ```
microsoft/beit-large-patch16-224-pt22k-ft22k
13c2a914288e08e09073f353d9a45e15aac0697e
2022-01-28T10:19:02.000Z
[ "pytorch", "jax", "beit", "image-classification", "dataset:imagenet", "dataset:imagenet-21k", "arxiv:2106.08254", "transformers", "vision", "license:apache-2.0" ]
image-classification
false
microsoft
null
microsoft/beit-large-patch16-224-pt22k-ft22k
608
2
transformers
2,146
--- license: apache-2.0 tags: - image-classification - vision datasets: - imagenet - imagenet-21k --- # BEiT (large-sized model, fine-tuned on ImageNet-22k) BEiT model pre-trained in a self-supervised fashion on ImageNet-22k - also called ImageNet-21k (14 million images, 21,841 classes) at resolution 224x224, and fine-tuned on the same dataset at resolution 224x224. It was introduced in the paper [BEIT: BERT Pre-Training of Image Transformers](https://arxiv.org/abs/2106.08254) by Hangbo Bao, Li Dong and Furu Wei and first released in [this repository](https://github.com/microsoft/unilm/tree/master/beit). Disclaimer: The team releasing BEiT did not write a model card for this model so this model card has been written by the Hugging Face team. ## Model description The BEiT model is a Vision Transformer (ViT), which is a transformer encoder model (BERT-like). In contrast to the original ViT model, BEiT is pretrained on a large collection of images in a self-supervised fashion, namely ImageNet-21k, at a resolution of 224x224 pixels. The pre-training objective for the model is to predict visual tokens from the encoder of OpenAI's DALL-E's VQ-VAE, based on masked patches. Next, the model was fine-tuned in a supervised fashion on ImageNet (also referred to as ILSVRC2012), a dataset comprising 1 million images and 1,000 classes, also at resolution 224x224. Images are presented to the model as a sequence of fixed-size patches (resolution 16x16), which are linearly embedded. Contrary to the original ViT models, BEiT models do use relative position embeddings (similar to T5) instead of absolute position embeddings, and perform classification of images by mean-pooling the final hidden states of the patches, instead of placing a linear layer on top of the final hidden state of the [CLS] token. By pre-training the model, it learns an inner representation of images that can then be used to extract features useful for downstream tasks: if you have a dataset of labeled images for instance, you can train a standard classifier by placing a linear layer on top of the pre-trained encoder. One typically places a linear layer on top of the [CLS] token, as the last hidden state of this token can be seen as a representation of an entire image. Alternatively, one can mean-pool the final hidden states of the patch embeddings, and place a linear layer on top of that. ## Intended uses & limitations You can use the raw model for image classification. See the [model hub](https://huggingface.co/models?search=microsoft/beit) to look for fine-tuned versions on a task that interests you. ### How to use Here is how to use this model to classify an image of the COCO 2017 dataset into one of the 1,000 ImageNet classes: ```python from transformers import BeitFeatureExtractor, BeitForImageClassification from PIL import Image import requests url = 'http://images.cocodataset.org/val2017/000000039769.jpg' image = Image.open(requests.get(url, stream=True).raw) feature_extractor = BeitFeatureExtractor.from_pretrained('microsoft/beit-large-patch16-224-pt22k-ft22k') model = BeitForImageClassification.from_pretrained('microsoft/beit-large-patch16-224-pt22k-ft22k') inputs = feature_extractor(images=image, return_tensors="pt") outputs = model(**inputs) logits = outputs.logits # model predicts one of the 21,841 ImageNet-22k classes predicted_class_idx = logits.argmax(-1).item() print("Predicted class:", model.config.id2label[predicted_class_idx]) ``` Currently, both the feature extractor and model support PyTorch. ## Training data The BEiT model was pretrained on [ImageNet-21k](http://www.image-net.org/), a dataset consisting of 14 million images and 21k classes, and fine-tuned on the same dataset. ## Training procedure ### Preprocessing The exact details of preprocessing of images during training/validation can be found [here](https://github.com/microsoft/unilm/blob/master/beit/datasets.py). Images are resized/rescaled to the same resolution (224x224) and normalized across the RGB channels with mean (0.5, 0.5, 0.5) and standard deviation (0.5, 0.5, 0.5). ### Pretraining For all pre-training related hyperparameters, we refer to page 15 of the [original paper](https://arxiv.org/abs/2106.08254). ## Evaluation results For evaluation results on several image classification benchmarks, we refer to tables 1 and 2 of the original paper. Note that for fine-tuning, the best results are obtained with a higher resolution. Of course, increasing the model size will result in better performance. ### BibTeX entry and citation info ```@article{DBLP:journals/corr/abs-2106-08254, author = {Hangbo Bao and Li Dong and Furu Wei}, title = {BEiT: {BERT} Pre-Training of Image Transformers}, journal = {CoRR}, volume = {abs/2106.08254}, year = {2021}, url = {https://arxiv.org/abs/2106.08254}, archivePrefix = {arXiv}, eprint = {2106.08254}, timestamp = {Tue, 29 Jun 2021 16:55:04 +0200}, biburl = {https://dblp.org/rec/journals/corr/abs-2106-08254.bib}, bibsource = {dblp computer science bibliography, https://dblp.org} } ``` ```bibtex @inproceedings{deng2009imagenet, title={Imagenet: A large-scale hierarchical image database}, author={Deng, Jia and Dong, Wei and Socher, Richard and Li, Li-Jia and Li, Kai and Fei-Fei, Li}, booktitle={2009 IEEE conference on computer vision and pattern recognition}, pages={248--255}, year={2009}, organization={Ieee} } ```
mpariente/ConvTasNet_Libri1Mix_enhsingle_8k
139ef2d9e78a9fbff8ab1811a45559574ecf7392
2021-09-23T16:12:15.000Z
[ "pytorch", "dataset:LibriMix", "dataset:enh_single", "asteroid", "audio", "ConvTasNet", "license:cc-by-sa-4.0" ]
null
false
mpariente
null
mpariente/ConvTasNet_Libri1Mix_enhsingle_8k
608
1
asteroid
2,147
--- tags: - asteroid - audio - ConvTasNet datasets: - LibriMix - enh_single license: cc-by-sa-4.0 --- ## Asteroid model Imported from this Zenodo [model page](https://zenodo.org/record/3970768). ## Description: This model was trained by Brij Mohan using the Librimix/ConvTasNet recipe in Asteroid. It was trained on the `enh_single` task of the Libri3Mix dataset. ## Training config: ```yaml data: n_src: 1 sample_rate: 8000 segment: 3 task: enh_single train_dir: data/wav8k/min/train-360 valid_dir: data/wav8k/min/dev filterbank: kernel_size: 16 n_filters: 512 stride: 8 masknet: bn_chan: 128 hid_chan: 512 mask_act: relu n_blocks: 8 n_repeats: 3 n_src: 1 skip_chan: 128 optim: lr: 0.001 optimizer: adam weight_decay: 0.0 training: batch_size: 24 early_stop: True epochs: 200 half_lr: True ``` ## Results: ```yaml si_sdr: 14.783675142685572 si_sdr_imp: 11.464625198953202 sdr: 15.497505907983102 sdr_imp: 12.07230150154914 sar: 15.497505907983102 sar_imp: 12.07230150154914 stoi: 0.9270030254700518 stoi_imp: 0.1320547197597893 ``` ## License notice: This work "ConvTasNet_Libri1Mix_enhsingle_8k" is a derivative of [LibriSpeech ASR corpus](http://www.openslr.org/12) by [Vassil Panayotov](https://github.com/vdp), used under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). "ConvTasNet_Libri1Mix_enhsingle_8k" is licensed under [Attribution-ShareAlike 3.0 Unported](https://creativecommons.org/licenses/by-sa/3.0/) by Manuel Pariente.
yair/HeadlineGeneration
201ba637b12dd26f54a5d047e50c1ddd68a41f94
2021-05-05T07:26:40.000Z
[ "pytorch", "bart", "text2text-generation", "transformers", "autotrain_compatible" ]
text2text-generation
false
yair
null
yair/HeadlineGeneration
608
1
transformers
2,148
hello
nateraw/bert-base-uncased-ag-news
5d0540f678d6603278d1ca4fab838e6746f53a82
2021-09-22T09:28:21.000Z
[ "pytorch", "jax", "bert", "text-classification", "en", "dataset:ag_news", "transformers", "ag_news", "license:mit" ]
text-classification
false
nateraw
null
nateraw/bert-base-uncased-ag-news
607
1
transformers
2,149
--- language: - en thumbnail: https://avatars3.githubusercontent.com/u/32437151?s=460&u=4ec59abc8d21d5feea3dab323d23a5860e6996a4&v=4 tags: - text-classification - ag_news - pytorch license: mit datasets: - ag_news metrics: - accuracy --- # bert-base-uncased-ag-news ## Model description `bert-base-uncased` finetuned on the AG News dataset using PyTorch Lightning. Sequence length 128, learning rate 2e-5, batch size 32, 4 T4 GPUs, 4 epochs. [The code can be found here](https://github.com/nateraw/hf-text-classification) #### Limitations and bias - Not the best model... ## Training data Data came from HuggingFace's `datasets` package. The data can be viewed [on nlp viewer](https://huggingface.co/nlp/viewer/?dataset=ag_news). ## Training procedure ... ## Eval results ...
facebook/wav2vec2-conformer-rel-pos-large
c35728baaed9c06f3301cb14f6e961f543a6851e
2022-06-15T08:11:48.000Z
[ "pytorch", "wav2vec2-conformer", "pretraining", "en", "dataset:librispeech_asr", "arxiv:2010.05171", "transformers", "speech", "license:apache-2.0" ]
null
false
facebook
null
facebook/wav2vec2-conformer-rel-pos-large
607
3
transformers
2,150
--- language: en datasets: - librispeech_asr tags: - speech license: apache-2.0 --- # Wav2Vec2-Conformer-Large with Relative Position Embeddings Wav2Vec2 Conformer with relative position embeddings, pretrained on 960 hours of Librispeech on 16kHz sampled speech audio. When using the model make sure that your speech input is also sampled at 16Khz. **Note**: This model does not have a tokenizer as it was pretrained on audio alone. In order to use this model **speech recognition**, a tokenizer should be created and the model should be fine-tuned on labeled text data. Check out [this blog](https://huggingface.co/blog/fine-tune-wav2vec2-english) for more in-detail explanation of how to fine-tune the model. **Paper**: [fairseq S2T: Fast Speech-to-Text Modeling with fairseq](https://arxiv.org/abs/2010.05171) **Authors**: Changhan Wang, Yun Tang, Xutai Ma, Anne Wu, Sravya Popuri, Dmytro Okhonko, Juan Pino The results of Wav2Vec2-Conformer can be found in Table 3 and Table 4 of the [official paper](https://arxiv.org/abs/2010.05171). The original model can be found under https://github.com/pytorch/fairseq/tree/master/examples/wav2vec#wav2vec-20. # Usage See [this notebook](https://colab.research.google.com/drive/1FjTsqbYKphl9kL-eILgUc-bl4zVThL8F?usp=sharing) for more information on how to fine-tune the model.
chenxran/orion-instance-generator
bc34fff8dbf8925734b42f3caa3aae6d94776c54
2022-05-21T16:31:10.000Z
[ "pytorch", "bart", "text2text-generation", "transformers", "autotrain_compatible" ]
text2text-generation
false
chenxran
null
chenxran/orion-instance-generator
607
null
transformers
2,151
Entry not found
EMBEDDIA/litlat-bert
0ff2fcc527af01aa224c997f8159b6ede2fdd034
2022-02-28T13:46:36.000Z
[ "pytorch", "xlm-roberta", "fill-mask", "lt", "lv", "en", "multilingual", "transformers", "license:cc-by-sa-4.0", "autotrain_compatible" ]
fill-mask
false
EMBEDDIA
null
EMBEDDIA/litlat-bert
606
2
transformers
2,152
--- language: - lt - lv - en - multilingual license: cc-by-sa-4.0 --- # LitLat BERT LitLat BERT is a trilingual model, using xlm-roberta-base architecture, trained on Lithuanian, Latvian, and English corpora. Focusing on three languages, the model performs better than [multilingual BERT](https://huggingface.co/bert-base-multilingual-cased), while still offering an option for cross-lingual knowledge transfer, which a monolingual model wouldn't. ### Named entity recognition evaluation We compare LitLat BERT with multilingual BERT (mBERT), XLM-RoBERTa (XLM-R) and monolingual Latvian BERT (LVBERT) (Znotins and Barzdins, 2020). The report the results as a macro F1 score of 3 named entity classes shared in all three datasets: person, location, organization. Language | mBERT | XLM-R | LVBERT | LitLat ---|---|---|---|--- Latvian | 0.830 | 0.865 | 0.797 | **0.881** Lithuanian | 0.797 | 0.817 | / | **0.850** English | 0.939 | 0.937 | / | **0.943**
NDugar/ZSD-microsoft-v2xxlmnli
f363b5890155e89a89e0d25b2db72bfc6c099813
2021-11-03T11:18:27.000Z
[ "pytorch", "deberta-v2", "text-classification", "en", "arxiv:2006.03654", "transformers", "deberta-v1", "deberta-mnli", "license:mit", "zero-shot-classification" ]
zero-shot-classification
false
NDugar
null
NDugar/ZSD-microsoft-v2xxlmnli
606
3
transformers
2,153
--- language: en tags: - deberta-v1 - deberta-mnli tasks: mnli thumbnail: https://huggingface.co/front/thumbnails/microsoft.png license: mit pipeline_tag: zero-shot-classification --- ## DeBERTa: Decoding-enhanced BERT with Disentangled Attention [DeBERTa](https://arxiv.org/abs/2006.03654) improves the BERT and RoBERTa models using disentangled attention and enhanced mask decoder. It outperforms BERT and RoBERTa on majority of NLU tasks with 80GB training data. Please check the [official repository](https://github.com/microsoft/DeBERTa) for more details and updates. This is the DeBERTa large model fine-tuned with MNLI task. #### Fine-tuning on NLU tasks We present the dev results on SQuAD 1.1/2.0 and several GLUE benchmark tasks. | Model | SQuAD 1.1 | SQuAD 2.0 | MNLI-m/mm | SST-2 | QNLI | CoLA | RTE | MRPC | QQP |STS-B | |---------------------------|-----------|-----------|-------------|-------|------|------|--------|-------|-------|------| | | F1/EM | F1/EM | Acc | Acc | Acc | MCC | Acc |Acc/F1 |Acc/F1 |P/S | | BERT-Large | 90.9/84.1 | 81.8/79.0 | 86.6/- | 93.2 | 92.3 | 60.6 | 70.4 | 88.0/- | 91.3/- |90.0/- | | RoBERTa-Large | 94.6/88.9 | 89.4/86.5 | 90.2/- | 96.4 | 93.9 | 68.0 | 86.6 | 90.9/- | 92.2/- |92.4/- | | XLNet-Large | 95.1/89.7 | 90.6/87.9 | 90.8/- | 97.0 | 94.9 | 69.0 | 85.9 | 90.8/- | 92.3/- |92.5/- | | [DeBERTa-Large](https://huggingface.co/microsoft/deberta-large)<sup>1</sup> | 95.5/90.1 | 90.7/88.0 | 91.3/91.1| 96.5|95.3| 69.5| 91.0| 92.6/94.6| 92.3/- |92.8/92.5 | | [DeBERTa-XLarge](https://huggingface.co/microsoft/deberta-xlarge)<sup>1</sup> | -/- | -/- | 91.5/91.2| 97.0 | - | - | 93.1 | 92.1/94.3 | - |92.9/92.7| | [DeBERTa-V2-XLarge](https://huggingface.co/microsoft/deberta-v2-xlarge)<sup>1</sup>|95.8/90.8| 91.4/88.9|91.7/91.6| **97.5**| 95.8|71.1|**93.9**|92.0/94.2|92.3/89.8|92.9/92.9| |**[DeBERTa-V2-XXLarge](https://huggingface.co/microsoft/deberta-v2-xxlarge)<sup>1,2</sup>**|**96.1/91.4**|**92.2/89.7**|**91.7/91.9**|97.2|**96.0**|**72.0**| 93.5| **93.1/94.9**|**92.7/90.3** |**93.2/93.1** | -------- #### Notes. - <sup>1</sup> Following RoBERTa, for RTE, MRPC, STS-B, we fine-tune the tasks based on [DeBERTa-Large-MNLI](https://huggingface.co/microsoft/deberta-large-mnli), [DeBERTa-XLarge-MNLI](https://huggingface.co/microsoft/deberta-xlarge-mnli), [DeBERTa-V2-XLarge-MNLI](https://huggingface.co/microsoft/deberta-v2-xlarge-mnli), [DeBERTa-V2-XXLarge-MNLI](https://huggingface.co/microsoft/deberta-v2-xxlarge-mnli). The results of SST-2/QQP/QNLI/SQuADv2 will also be slightly improved when start from MNLI fine-tuned models, however, we only report the numbers fine-tuned from pretrained base models for those 4 tasks. - <sup>2</sup> To try the **XXLarge** model with **[HF transformers](https://huggingface.co/transformers/main_classes/trainer.html)**, you need to specify **--sharded_ddp** ```bash cd transformers/examples/text-classification/ export TASK_NAME=mrpc python -m torch.distributed.launch --nproc_per_node=8 run_glue.py --model_name_or_path microsoft/deberta-v2-xxlarge \\\n--task_name $TASK_NAME --do_train --do_eval --max_seq_length 128 --per_device_train_batch_size 4 \\\n--learning_rate 3e-6 --num_train_epochs 3 --output_dir /tmp/$TASK_NAME/ --overwrite_output_dir --sharded_ddp --fp16 ``` ### Citation If you find DeBERTa useful for your work, please cite the following paper: ``` latex @inproceedings{ he2021deberta, title={DEBERTA: DECODING-ENHANCED BERT WITH DISENTANGLED ATTENTION}, author={Pengcheng He and Xiaodong Liu and Jianfeng Gao and Weizhu Chen}, booktitle={International Conference on Learning Representations}, year={2021}, url={https://openreview.net/forum?id=XPZIaotutsD} } ```
lgris/wav2vec2-large-xlsr-open-brazilian-portuguese
861b31010394ed861460cffbca062643648e5793
2022-04-01T20:32:58.000Z
[ "pytorch", "wav2vec2", "automatic-speech-recognition", "pt", "dataset:common_voice", "dataset:mls", "dataset:cetuc", "dataset:lapsbm", "dataset:voxforge", "arxiv:2012.03411", "transformers", "audio", "speech", "portuguese-speech-corpus", "PyTorch", "hf-asr-leaderboard", "license:apache-2.0", "model-index" ]
automatic-speech-recognition
false
lgris
null
lgris/wav2vec2-large-xlsr-open-brazilian-portuguese
606
2
transformers
2,154
--- language: pt datasets: - common_voice - mls - cetuc - lapsbm - voxforge metrics: - wer tags: - audio - speech - wav2vec2 - pt - portuguese-speech-corpus - automatic-speech-recognition - speech - PyTorch - hf-asr-leaderboard license: apache-2.0 model-index: - name: Lucas Gris XLSR Wav2Vec2 Large 53 Brazilian Portuguese results: - task: name: Speech Recognition type: automatic-speech-recognition metrics: - name: Test WER type: wer value: 12.905054857823264% --- # Wav2vec 2.0 With Open Brazilian Portuguese Datasets This a the demonstration of a fine-tuned Wav2vec model for Brazilian Portuguese using the following datasets: - [CETUC](http://www02.smt.ufrj.br/~igor.quintanilha/alcaim.tar.gz): contains approximately 145 hours of Brazilian Portuguese speech distributed among 50 male and 50 female speakers, each pronouncing approximately 1,000 phonetically balanced sentences selected from the [CETEN-Folha](https://www.linguateca.pt/cetenfolha/) corpus. - [Multilingual Librispeech (MLS)](https://arxiv.org/abs/2012.03411): a massive dataset available in many languages. The MLS is based on audiobook recordings in public domain like [LibriVox](https://librivox.org/). The dataset contains a total of 6k hours of transcribed data in many languages. The set in Portuguese [used in this work](http://www.openslr.org/94/) (mostly Brazilian variant) has approximately 284 hours of speech, obtained from 55 audiobooks read by 62 speakers. - [VoxForge](http://www.voxforge.org/): is a project with the goal to build open datasets for acoustic models. The corpus contains approximately 100 speakers and 4,130 utterances of Brazilian Portuguese, with sample rates varying from 16kHz to 44.1kHz. - [Common Voice 6.1](https://commonvoice.mozilla.org/pt) (_only train_): is a project proposed by Mozilla Foundation with the goal to create a wide open dataset in different languages to train ASR models. In this project, volunteers donate and validate speech using the [oficial site](https://commonvoice.mozilla.org/pt). The set in Portuguese (mostly Brazilian variant) used in this work is the 6.1 version (pt_63h_2020-12-11) that contains about 50 validated hours and 1,120 unique speakers. - [Lapsbm](https://github.com/falabrasil/gitlab-resources): "Falabrasil - UFPA" is a dataset used by the Fala Brasil group to benchmark ASR systems in Brazilian Portuguese. Contains 35 speakers (10 females), each one pronouncing 20 unique sentences, totalling 700 utterances in Brazilian Portuguese. The audios were recorded in 22.05 kHz without environment control. These datasets were combined to build a larger Brazilian Portuguese dataset. All data was used for training except Common Voice dev/test sets, that were used for validation/test respectively. The original model was fine-tuned using [fairseq](https://github.com/pytorch/fairseq). This notebook uses a converted version of the original one. The link to the original fairseq model is available [here](https://drive.google.com/drive/folders/1XTKIUB4kp3oYOavwH97wq8IPFsxP5sNz?usp=sharing). This model was trained in 80k updates. #### Datasets in number of instances and number of frames The following image shows the overall distribution of the dataset: ![datasets](https://drive.google.com/uc?export=view&id=1DF2_PehB2pZlEJLcBA7yeZQ9EAuLGh_r) #### Transcription examples | Text | Transcription | |------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------| | É comum os usuários confundirem software livre com software livre | É comum os __usuares__ __confunder em__ __softwerlivr__ com __softwerlivre__ | | Ele fez tanto ghostwriting que ele começa a se sentir como um fantasma também | Ele fez tanto __golstraitn__ que ele __começou__ a se sentir como um fantasma também | | Arnold apresentou um gráfico mostrando quantas cegonhas ele havia contado nos últimos dez anos | Arnold apresentou um gráfico mostrando quantas __segonhas__ ele havia contado nos últimos dez anos | | Mais cedo ou mais tarde eles descobrirão como ler esses hieróglifos | Mais __sedo__ ou mais tarde eles descobriram como __de__ esses __ierogrôficos__ | | Viver juntos compartilhar objetivos e ter um bom relacionamento | __E ver__ juntos __signafica__ viver juntos ou __fartlhar__ objetivos ter um bom __relacionamentoo__ | | Da mesma forma uma patente pode impedir que concorrentes desenvolvam produtos similares | Da mesma forma uma patente pode impedir que concorrentes __desenvolva__ produtos similares | | Duas mulheres e uma menina levantam com troféus | Duas mulheres e uma menina levantam com __trofés__ | | Esse acrobata de circo deve ter um sistema vestibular bem treinado pensou o espectador | Esse acrobata de __cirko__ deve ter um sistema vestibular __bemtreinado__ pensou o espectador | | Durante a exposição o tribunal pode fazer quaisquer perguntas ou esclarecimentos que considere apropriados | Durante a exposição o tribunal pode fazer quaisquer perguntas ou esclarecimentos que considere __apropriado__ | ## Imports and dependencies ```python %%capture !pip install datasets !pip install jiwer !pip install torchaudio !pip install transformers !pip install soundfile ``` ```python import torchaudio from datasets import load_dataset, load_metric from transformers import ( Wav2Vec2ForCTC, Wav2Vec2Processor, ) import torch import re import sys ``` ## Preparation ```python chars_to_ignore_regex = '[\,\?\.\!\;\:\"]' # noqa: W605 wer = load_metric("wer") device = "cuda" ``` ```python model_name = 'lgris/wav2vec2-large-xlsr-open-brazilian-portuguese' model = Wav2Vec2ForCTC.from_pretrained(model_name).to(device) processor = Wav2Vec2Processor.from_pretrained(model_name) ``` ```python def map_to_pred(batch): features = processor(batch["speech"], sampling_rate=batch["sampling_rate"][0], padding=True, return_tensors="pt") input_values = features.input_values.to(device) attention_mask = features.attention_mask.to(device) with torch.no_grad(): logits = model(input_values, attention_mask=attention_mask).logits pred_ids = torch.argmax(logits, dim=-1) batch["predicted"] = processor.batch_decode(pred_ids) batch["predicted"] = [pred.lower() for pred in batch["predicted"]] batch["target"] = batch["sentence"] return batch ``` ## Tests ### Test against Common Voice (In-domain) ```python dataset = load_dataset("common_voice", "pt", split="test", data_dir="./cv-corpus-6.1-2020-12-11") resampler = torchaudio.transforms.Resample(orig_freq=48_000, new_freq=16_000) def map_to_array(batch): speech, _ = torchaudio.load(batch["path"]) batch["speech"] = resampler.forward(speech.squeeze(0)).numpy() batch["sampling_rate"] = resampler.new_freq batch["sentence"] = re.sub(chars_to_ignore_regex, '', batch["sentence"]).lower().replace("’", "'") return batch ``` ```python ds = dataset.map(map_to_array) result = ds.map(map_to_pred, batched=True, batch_size=1, remove_columns=list(ds.features.keys())) print(wer.compute(predictions=result["predicted"], references=result["target"])) for pred, target in zip(result["predicted"][:10], result["target"][:10]): print(pred, "|", target) ``` 0.12905054857823264 nem o varanin os altros influmindo os de teterno um bombederster | nem o radar nem os outros instrumentos detectaram o bombardeiro stealth pedir dinheiro é emprestado das pessoas do aldeia | pedir dinheiro emprestado às pessoas da aldeia oito | oito teno calcos | trancá-los realizaram a investigação para resolver o problema | realizar uma investigação para resolver o problema iotube ainda é a melhor plataforma de vídeos | o youtube ainda é a melhor plataforma de vídeos menina e menino beijando nas sombras | menina e menino beijando nas sombras eu sou o senhor | eu sou o senhor duas metcas sentam-se para baixo randes jornais | duas mulheres que sentam-se para baixo lendo jornais eu originalmente esperava | eu originalmente esperava **Result**: 12.90% ### Test against [TEDx](http://www.openslr.org/100/) (Out-of-domain) ```python !gdown --id 1HJEnvthaGYwcV_whHEywgH2daIN4bQna !tar -xf tedx.tar.gz ``` ```python dataset = load_dataset('csv', data_files={'test': 'tedx/test.csv'})['test'] def map_to_array(batch): speech, _ = torchaudio.load(batch["path"]) batch["speech"] = speech.squeeze(0).numpy() batch["sampling_rate"] = resampler.new_freq batch["sentence"] = re.sub(chars_to_ignore_regex, '', batch["sentence"]).lower().replace("’", "'") return batch ``` ```python ds = dataset.map(map_to_array) result = ds.map(map_to_pred, batched=True, batch_size=1, remove_columns=list(ds.features.keys())) print(wer.compute(predictions=result["predicted"], references=result["target"])) for pred, target in zip(result["predicted"][:10], result["target"][:10]): print(pred, "|", target) ``` 0.35215851987208774 com isso a gente vê que essa rede de pactuação de de deparcerias nos remete a um raciocínio lógico que ao que a gente crê que é a prevenção | com isso a gente vê que essa rede de pactuação de parcerias nos remete a um raciocínio lógico que é o que a gente crê que é a prevenção ente vai para o resultado | e aí a gente vai pro resultado curiosidade hé o que eu descobri desde que comecei a fazer pesquisa lá no ensino médio | e a curiosidade é algo que descobri desde que comecei a fazer pesquisa lá no ensino médio val des quemesho | há vários caminhos que é uma opcissão por comer soldado | que é uma obsessão por comer saudável isso é tão é forte algoltão universal que existem dados que mostram que setenta e cinco por cento das reuniões são dominadas pela voz masculina | e isso é tão forte é algo tão universal que existem dados que mostram que das reuniões são dominadas pela voz masculina não era exatamente isso não estávamos deveto | e não era exatamente isso que nós estávamos a ver durante meci do médio ofiz pesquisa estudei numa escola que chamam a fundação liberate ficava relativamente próximo daqui | durante o ensino médio eu fiz pesquisa estudei numa escola que se chama fundação liberato que fica relativamente próxima daqui oito anos atrás eu fui apresentado por uma doença que até então eu não conhecia e que é bem provável que a maior parte de nós todos aqui não conheçamos | oito anos atrás fui apresentado para uma doença que até então eu não conhecia e que é bem provável que a maior parte de nós todos aqui não conheçamos o terceiro é o museu do ripiopeco | o terceiro é o museu do hip hop **Result**: 35.21%
uer/gpt2-chinese-couplet
62fc2e851dc4df9d3e9d89ddc3f7c1e5a29e3a21
2022-02-20T05:01:07.000Z
[ "pytorch", "tf", "jax", "gpt2", "text-generation", "zh", "transformers" ]
text-generation
false
uer
null
uer/gpt2-chinese-couplet
606
2
transformers
2,155
--- language: zh widget: - text: "[CLS]国 色 天 香 ， 姹 紫 嫣 红 ， 碧 水 青 云 欣 共 赏 -" --- # Chinese Couplet GPT2 Model ## Model description The model is used to generate Chinese couplets. You can download the model either from the [GPT2-Chinese Github page](https://github.com/Morizeyao/GPT2-Chinese), or via HuggingFace from the link [gpt2-chinese-couplet](https://huggingface.co/uer/gpt2-chinese-couplet). Since the parameter skip_special_tokens is used in the pipelines.py, special tokens such as [SEP], [UNK] will be deleted, the output results of Hosted inference API (right) may not be properly displayed.. ## How to use You can use the model directly with a pipeline for text generation: When the parameter skip_special_tokens is True: ```python >>> from transformers import BertTokenizer, GPT2LMHeadModel, TextGenerationPipeline >>> tokenizer = BertTokenizer.from_pretrained("uer/gpt2-chinese-couplet") >>> model = GPT2LMHeadModel.from_pretrained("uer/gpt2-chinese-couplet") >>> text_generator = TextGenerationPipeline(model, tokenizer) >>> text_generator("[CLS]丹 枫 江 冷 人 初 去 -", max_length=25, do_sample=True) [{'generated_text': '[CLS]丹 枫 江 冷 人 初 去 - 黄 叶 声 从 天 外 来 阅 旗'}] ``` When the parameter skip_special_tokens is False: ```python >>> from transformers import BertTokenizer, GPT2LMHeadModel, TextGenerationPipeline >>> tokenizer = BertTokenizer.from_pretrained("uer/gpt2-chinese-couplet") >>> model = GPT2LMHeadModel.from_pretrained("uer/gpt2-chinese-couplet") >>> text_generator = TextGenerationPipeline(model, tokenizer) >>> text_generator("[CLS]丹 枫 江 冷 人 初 去 -", max_length=25, do_sample=True) [{'generated_text': '[CLS]丹 枫 江 冷 人 初 去 - 黄 叶 声 我 酒 不 辞 [SEP] [SEP] [SEP] [SEP] [SEP] [SEP] [SEP] [SEP] [SEP]'}] ``` ## Training data Training data contains 700,000 Chinese couplets which are collected by [couplet-clean-dataset](https://github.com/v-zich/couplet-clean-dataset). ## Training procedure The model is pre-trained by [UER-py](https://github.com/dbiir/UER-py/) on [Tencent Cloud](https://cloud.tencent.com/). We pre-train 25,000 steps with a sequence length of 64. ``` python3 preprocess.py --corpus_path corpora/couplet.txt \ --vocab_path models/google_zh_vocab.txt \ --dataset_path couplet_dataset.pt --processes_num 16 \ --seq_length 64 --data_processor lm ``` ``` python3 pretrain.py --dataset_path couplet_dataset.pt \ --vocab_path models/google_zh_vocab.txt \ --config_path models/gpt2/config.json \ --output_model_path models/couplet_gpt2_model.bin \ --world_size 8 --gpu_ranks 0 1 2 3 4 5 6 7 \ --total_steps 25000 --save_checkpoint_steps 5000 --report_steps 1000 \ --learning_rate 5e-4 --batch_size 64 ``` Finally, we convert the pre-trained model into Huggingface's format: ``` python3 scripts/convert_gpt2_from_uer_to_huggingface.py --input_model_path couplet_gpt2_model.bin-25000 \ --output_model_path pytorch_model.bin \ --layers_num 12 ``` ### BibTeX entry and citation info ``` @article{radford2019language, title={Language Models are Unsupervised Multitask Learners}, author={Radford, Alec and Wu, Jeff and Child, Rewon and Luan, David and Amodei, Dario and Sutskever, Ilya}, year={2019} } @article{zhao2019uer, title={UER: An Open-Source Toolkit for Pre-training Models}, author={Zhao, Zhe and Chen, Hui and Zhang, Jinbin and Zhao, Xin and Liu, Tao and Lu, Wei and Chen, Xi and Deng, Haotang and Ju, Qi and Du, Xiaoyong}, journal={EMNLP-IJCNLP 2019}, pages={241}, year={2019} } ```
alon-albalak/xlm-roberta-large-xquad
7b9dc808bf9ffd04e568f4be1836d805f48e40a2
2021-11-05T20:23:38.000Z
[ "pytorch", "xlm-roberta", "question-answering", "dataset:xquad", "transformers", "multilingual", "autotrain_compatible" ]
question-answering
false
alon-albalak
null
alon-albalak/xlm-roberta-large-xquad
605
1
transformers
2,156
--- tags: - multilingual datasets: - xquad --- # xlm-roberta-large for multilingual QA # Overview **Language Model**: xlm-roberta-large \ **Downstream task**: Extractive QA \ **Training data**: [XQuAD](https://github.com/deepmind/xquad) \ **Testing Data**: [XQuAD](https://github.com/deepmind/xquad) # Hyperparameters ```python batch_size = 48 n_epochs = 13 max_seq_len = 384 doc_stride = 128 learning_rate = 3e-5 ``` # Performance Evaluated on held-out test set from XQuAD ```python "exact_match": 87.12546816479401, "f1": 94.77703248802527, "test_samples": 2307 ``` # Usage ## In Transformers ```python from transformers import AutoModelForQuestionAnswering, AutoTokenizer, pipeline model_name = "alon-albalak/xlm-roberta-large-xquad" # a) Get predictions nlp = pipeline('question-answering', model=model_name, tokenizer=model_name) QA_input = { 'question': 'Why is model conversion important?', 'context': 'The option to convert models between FARM and transformers gives freedom to the user and let people easily switch between frameworks.' } res = nlp(QA_input) # b) Load model & tokenizer model = AutoModelForQuestionAnswering.from_pretrained(model_name) tokenizer = AutoTokenizer.from_pretrained(model_name) ``` ## In FARM ```python from farm.modeling.adaptive_model import AdaptiveModel from farm.modeling.tokenization import Tokenizer from farm.infer import QAInferencer model_name = "alon-albalak/xlm-roberta-large-xquad" # a) Get predictions nlp = QAInferencer.load(model_name) QA_input = [{"questions": ["Why is model conversion important?"], "text": "The option to convert models between FARM and transformers gives freedom to the user and let people easily switch between frameworks."}] res = nlp.inference_from_dicts(dicts=QA_input, rest_api_schema=True) # b) Load model & tokenizer model = AdaptiveModel.convert_from_transformers(model_name, device="cpu", task_type="question_answering") tokenizer = Tokenizer.load(model_name) ``` ## In Haystack ```python reader = FARMReader(model_name_or_path="alon-albalak/xlm-roberta-large-xquad") # or reader = TransformersReader(model="alon-albalak/xlm-roberta-large-xquad",tokenizer="alon-albalak/xlm-roberta-large-xquad") ``` Usage instructions for FARM and Haystack were adopted from https://huggingface.co/deepset/xlm-roberta-large-squad2
a1noack/bart-large-gigaword
227fafcd7b922f8abcf0d5f0a8880d15ae5b302e
2021-07-21T21:26:04.000Z
[ "pytorch", "bart", "dataset:gigaword", "transformers", "summarization", "license:mit" ]
summarization
false
a1noack
null
a1noack/bart-large-gigaword
602
null
transformers
2,157
--- tags: - summarization datasets: - gigaword license: mit thumbnail: https://en.wikipedia.org/wiki/Bart_Simpson#/media/File:Bart_Simpson_200px.png --- # BART for Gigaword - This model was created by fine-tuning the `facebook/bart-large-cnn` weights (also on HuggingFace) for the Gigaword dataset. The model was fine-tuned on the Gigaword training set for 3 epochs, and the model with the highest ROUGE-1 score on the training set batches was kept. - The BART Tokenizer for CNN-Dailymail was used in the fine-tuning process and that is the tokenizer that will be loaded automatically when doing: ``` from transformers import AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("a1noack/bart-large-gigaword") ``` # Summary generation - This model achieves ROUGE-1 / ROUGE-2 / ROUGE-L of 37.28 / 18.58 / 34.53 on the Gigaword test set; this is pretty good when compared to PEGASUS, `google/pegasus-gigaword`, which achieves 39.12 / 19.86 / 36.24. - To achieve these results, generate text using the code below. `text_list` is a list of input text string. ``` input_ids_list = tokenizer(text_list, truncation=True, max_length=128, return_tensors='pt', padding=True)['input_ids'] output_ids_list = model.generate(input_ids_list, min_length=0) outputs_list = tokenizer.batch_decode(output_ids_list, skip_special_tokens=True, clean_up_tokenization_spaces=False) ```
facebook/dino-vits8
fc5da873905bdf18d2fbad89dafc45de22d8f4fa
2021-08-25T17:37:35.000Z
[ "pytorch", "vit", "feature-extraction", "dataset:imagenet-1k", "arxiv:2010.11929", "arxiv:2104.14294", "transformers", "dino", "license:apache-2.0" ]
feature-extraction
false
facebook
null
facebook/dino-vits8
602
2
transformers
2,158
--- license: apache-2.0 tags: - dino datasets: - imagenet-1k --- # Vision Transformer (small-sized model, patch size 8) trained using DINO Vision Transformer (ViT) model trained using the DINO method. It was introduced in the paper [Emerging Properties in Self-Supervised Vision Transformers](https://arxiv.org/abs/2010.11929) by Mathilde Caron, Hugo Touvron, Ishan Misra, Hervé Jégou, Julien Mairal, Piotr Bojanowski, Armand Joulin and first released in [this repository](https://github.com/facebookresearch/dino). Disclaimer: The team releasing DINO did not write a model card for this model so this model card has been written by the Hugging Face team. ## Model description The Vision Transformer (ViT) is a transformer encoder model (BERT-like) pretrained on a large collection of images in a self-supervised fashion, namely ImageNet-1k, at a resolution of 224x224 pixels. Images are presented to the model as a sequence of fixed-size patches (resolution 8x8), which are linearly embedded. One also adds a [CLS] token to the beginning of a sequence to use it for classification tasks. One also adds absolute position embeddings before feeding the sequence to the layers of the Transformer encoder. Note that this model does not include any fine-tuned heads. By pre-training the model, it learns an inner representation of images that can then be used to extract features useful for downstream tasks: if you have a dataset of labeled images for instance, you can train a standard classifier by placing a linear layer on top of the pre-trained encoder. One typically places a linear layer on top of the [CLS] token, as the last hidden state of this token can be seen as a representation of an entire image. ## Intended uses & limitations You can use the raw model for image classification. See the [model hub](https://huggingface.co/models?search=google/vit) to look for fine-tuned versions on a task that interests you. ### How to use Here is how to use this model: ```python from transformers import ViTFeatureExtractor, ViTModel from PIL import Image import requests url = 'http://images.cocodataset.org/val2017/000000039769.jpg' image = Image.open(requests.get(url, stream=True).raw) feature_extractor = ViTFeatureExtractor.from_pretrained('facebook/dino-vits8') model = ViTModel.from_pretrained('facebook/dino-vits8') inputs = feature_extractor(images=image, return_tensors="pt") outputs = model(**inputs) last_hidden_states = outputs.last_hidden_state ``` ### BibTeX entry and citation info ```bibtex @article{DBLP:journals/corr/abs-2104-14294, author = {Mathilde Caron and Hugo Touvron and Ishan Misra and Herv{\'{e}} J{\'{e}}gou and Julien Mairal and Piotr Bojanowski and Armand Joulin}, title = {Emerging Properties in Self-Supervised Vision Transformers}, journal = {CoRR}, volume = {abs/2104.14294}, year = {2021}, url = {https://arxiv.org/abs/2104.14294}, archivePrefix = {arXiv}, eprint = {2104.14294}, timestamp = {Tue, 04 May 2021 15:12:43 +0200}, biburl = {https://dblp.org/rec/journals/corr/abs-2104-14294.bib}, bibsource = {dblp computer science bibliography, https://dblp.org} } ```
d4data/biomedical-ner-all
7aa74de711ded74f1e4dd7af873d5ec4c5c608f9
2022-06-26T05:40:58.000Z
[ "pytorch", "distilbert", "token-classification", "en", "transformers", "Token Classification", "license:apache-2.0", "co2_eq_emissions", "autotrain_compatible" ]
token-classification
false
d4data
null
d4data/biomedical-ner-all
602
1
transformers
2,159
--- license: apache-2.0 language: - en tags: - Token Classification co2_eq_emissions: 0.0279399890043426 Kg widget: - text: "CASE: A 28-year-old previously healthy man presented with a 6-week history of palpitations. The symptoms occurred during rest, 2–3 times per week, lasted up to 30 minutes at a time and were associated with dyspnea. Except for a grade 2/6 holosystolic tricuspid regurgitation murmur (best heard at the left sternal border with inspiratory accentuation), physical examination yielded unremarkable findings." example_title: "example 1" - text: "A 63-year-old woman with no known cardiac history presented with a sudden onset of dyspnea requiring intubation and ventilatory support out of hospital. She denied preceding symptoms of chest discomfort, palpitations, syncope or infection. The patient was afebrile and normotensive, with a sinus tachycardia of 140 beats/min." example_title: "example 2" - text: "A 48 year-old female presented with vaginal bleeding and abnormal Pap smears. Upon diagnosis of invasive non-keratinizing SCC of the cervix, she underwent a radical hysterectomy with salpingo-oophorectomy which demonstrated positive spread to the pelvic lymph nodes and the parametrium. Pathological examination revealed that the tumour also extensively involved the lower uterine segment." example_title: "example 3" --- ## About the Model An English Named Entity Recognition model, trained on Maccrobat to recognize the bio-medical entities (107 entities) from a given text corpus (case reports etc.). This model was built on top of distilbert-base-uncased - Dataset : Maccrobat https://figshare.com/articles/dataset/MACCROBAT2018/9764942 - Carbon emission : 0.0279399890043426 Kg - Training time : 30.16527 minute - GPU used : 1 x GeForce RTX 3060 Laptop GPU ## Usage The easiest way is to load the inference api from huggingface and second method is through the pipeline object offered by transformers library. ```python from transformers import pipeline from transformers import AutoTokenizer, AutoModelForTokenClassification tokenizer = AutoTokenizer.from_pretrained("d4data/biomedical-ner-all") model = AutoModelForTokenClassification.from_pretrained("d4data/biomedical-ner-all") pipe = pipeline("ner", model=model, tokenizer=tokenizer, aggregation_strategy="simple") # pass device=0 if using gpu pipe("""The patient reported no recurrence of palpitations at follow-up 6 months after the ablation.""") ``` ## Author This model is part of the Research topic "AI in Biomedical field" conducted by Deepak John Reji, Shaina Raza. If you use this work (code, model or dataset), please star at: > repo yet to create, <>
jjzha/spanbert-base-cased
b7120cdda3f5dd79b61f49cfb86ae4ee45b8294c
2022-07-26T08:14:45.000Z
[ "pytorch", "bert", "en", "transformers", "retrained", "SpanBERT" ]
null
false
jjzha
null
jjzha/spanbert-base-cased
601
null
transformers
2,160
--- language: - en tags: - retrained - SpanBERT --- SpanBERT This is the SpanBERT model from: Mike Zhang, Kristian Nørgaard Jensen, Sif Dam Sonniks, and Barbara Plank. __SkillSpan: Hard and Soft Skill Extraction from Job Postings__. Proceedings of the 2022 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies. This model is pre-trained from scratch on the BookCorpus and WikiData. To pre-train from scratch we use the code from Splinter: https://github.com/oriram/splinter. On our job posting dataset, we found that our `spanbert-base-cased` model works better than the original. More information can be found in the paper. If you use this model, please cite the following paper: ``` @inproceedings{zhang-etal-2022-skillspan, title = "{S}kill{S}pan: Hard and Soft Skill Extraction from {E}nglish Job Postings", author = "Zhang, Mike and Jensen, Kristian N{\o}rgaard and Sonniks, Sif and Plank, Barbara", booktitle = "Proceedings of the 2022 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies", month = jul, year = "2022", address = "Seattle, United States", publisher = "Association for Computational Linguistics", url = "https://aclanthology.org/2022.naacl-main.366", pages = "4962--4984", abstract = "Skill Extraction (SE) is an important and widely-studied task useful to gain insights into labor market dynamics. However, there is a lacuna of datasets and annotation guidelines; available datasets are few and contain crowd-sourced labels on the span-level or labels from a predefined skill inventory. To address this gap, we introduce SKILLSPAN, a novel SE dataset consisting of 14.5K sentences and over 12.5K annotated spans. We release its respective guidelines created over three different sources annotated for hard and soft skills by domain experts. We introduce a BERT baseline (Devlin et al., 2019). To improve upon this baseline, we experiment with language models that are optimized for long spans (Joshi et al., 2020; Beltagy et al., 2020), continuous pre-training on the job posting domain (Han and Eisenstein, 2019; Gururangan et al., 2020), and multi-task learning (Caruana, 1997). Our results show that the domain-adapted models significantly outperform their non-adapted counterparts, and single-task outperforms multi-task learning.", } ```
Raychanan/bert-base-chinese-FineTuned-Binary-Best
cea5c20e347c9aa770860109672cb356f83f5c12
2021-05-18T21:56:08.000Z
[ "pytorch", "jax", "bert", "text-classification", "transformers" ]
text-classification
false
Raychanan
null
Raychanan/bert-base-chinese-FineTuned-Binary-Best
600
null
transformers
2,161
Entry not found
ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition
17cf17c4ec7c4d083a3ac50a3c98d44088434cee
2021-09-21T20:59:32.000Z
[ "pytorch", "tensorboard", "wav2vec2", "audio-classification", "transformers", "generated_from_trainer", "license:apache-2.0" ]
audio-classification
false
ehcalabres
null
ehcalabres/wav2vec2-lg-xlsr-en-speech-emotion-recognition
599
11
transformers
2,162
--- license: apache-2.0 tags: - generated_from_trainer metrics: - accuracy model_index: name: wav2vec2-lg-xlsr-en-speech-emotion-recognition --- # Speech Emotion Recognition By Fine-Tuning Wav2Vec 2.0 The model is a fine-tuned version of [jonatasgrosman/wav2vec2-large-xlsr-53-english](https://huggingface.co/jonatasgrosman/wav2vec2-large-xlsr-53-english) for a Speech Emotion Recognition (SER) task. The dataset used to fine-tune the original pre-trained model is the [RAVDESS dataset](https://zenodo.org/record/1188976#.YO6yI-gzaUk). This dataset provides 1440 samples of recordings from actors performing on 8 different emotions in English, which are: ```python emotions = ['angry', 'calm', 'disgust', 'fearful', 'happy', 'neutral', 'sad', 'surprised'] ``` It achieves the following results on the evaluation set: - Loss: 0.5023 - Accuracy: 0.8223 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 0.0001 - train_batch_size: 4 - eval_batch_size: 4 - seed: 42 - gradient_accumulation_steps: 2 - total_train_batch_size: 8 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-08 - lr_scheduler_type: linear - num_epochs: 3 - mixed_precision_training: Native AMP ### Training results | Training Loss | Epoch | Step | Validation Loss | Accuracy | |:-------------:|:-----:|:----:|:---------------:|:--------:| | 2.0752 | 0.21 | 30 | 2.0505 | 0.1359 | | 2.0119 | 0.42 | 60 | 1.9340 | 0.2474 | | 1.8073 | 0.63 | 90 | 1.5169 | 0.3902 | | 1.5418 | 0.84 | 120 | 1.2373 | 0.5610 | | 1.1432 | 1.05 | 150 | 1.1579 | 0.5610 | | 0.9645 | 1.26 | 180 | 0.9610 | 0.6167 | | 0.8811 | 1.47 | 210 | 0.8063 | 0.7178 | | 0.8756 | 1.68 | 240 | 0.7379 | 0.7352 | | 0.8208 | 1.89 | 270 | 0.6839 | 0.7596 | | 0.7118 | 2.1 | 300 | 0.6664 | 0.7735 | | 0.4261 | 2.31 | 330 | 0.6058 | 0.8014 | | 0.4394 | 2.52 | 360 | 0.5754 | 0.8223 | | 0.4581 | 2.72 | 390 | 0.4719 | 0.8467 | | 0.3967 | 2.93 | 420 | 0.5023 | 0.8223 | ## Contact Any doubt, contact me on [Twitter](https://twitter.com/ehcalabres) (GitHub repo soon). ### Framework versions - Transformers 4.8.2 - Pytorch 1.9.0+cu102 - Datasets 1.9.0 - Tokenizers 0.10.3
BlackSamorez/rudialogpt3_medium_based_on_gpt2_2ch
59d120c6cb013de2c3909d22e57a2260e0e16df7
2022-06-05T14:29:01.000Z
[ "pytorch", "gpt2", "text-generation", "ru", "transformers", "conversational" ]
conversational
false
BlackSamorez
null
BlackSamorez/rudialogpt3_medium_based_on_gpt2_2ch
599
1
transformers
2,163
--- language: - ru thumbnail: tags: - conversational --- DialoGPT on Russian language Based on [Grossmend/rudialogpt3_medium_based_on_gpt2](https://huggingface.co/Grossmend/rudialogpt3_medium_based_on_gpt2) Fine tuned on [2ch /b/ dialogues](https://huggingface.co/datasets/BlackSamorez/2ch_b_dialogues) data. To improve performance replies were filtered by obscenity. Used in [Ebanko](https://t.me/toxic_ebanko_bot) **Telegram bot**. You can find code for deployment on [my github](https://github.com/BlackSamorez/ebanko).
deutsche-telekom/mt5-small-sum-de-en-v1
449e879e5554349c284d9a45bef28aaba4385f30
2021-09-23T13:48:30.000Z
[ "pytorch", "mt5", "text2text-generation", "de", "en", "dataset:cnn_dailymail", "dataset:xsum", "dataset:wiki_lingua", "dataset:mlsum", "dataset:swiss_text_2019", "transformers", "summarization", "license:cc-by-nc-sa-4.0", "autotrain_compatible" ]
summarization
false
deutsche-telekom
null
deutsche-telekom/mt5-small-sum-de-en-v1
598
3
transformers
2,164
--- language: - de - en license: cc-by-nc-sa-4.0 tags: - summarization datasets: - cnn_dailymail - xsum - wiki_lingua - mlsum - swiss_text_2019 --- # mT5-small-sum-de-en-v1 This is a bilingual summarization model for English and German. It is based on the multilingual T5 model [google/mt5-small](https://huggingface.co/google/mt5-small). [![One Conversation](https://raw.githubusercontent.com/telekom/HPOflow/main/docs/source/imgs/1c-logo.png)](https://www.welove.ai/) This model is provided by the [One Conversation](https://www.welove.ai/) team of [Deutsche Telekom AG](https://www.telekom.com/). ## Training The training was conducted with the following hyperparameters: - base model: [google/mt5-small](https://huggingface.co/google/mt5-small) - source_prefix: `"summarize: "` - batch size: 3 - max_source_length: 800 - max_target_length: 96 - warmup_ratio: 0.3 - number of train epochs: 10 - gradient accumulation steps: 2 - learning rate: 5e-5 ## Datasets and Preprocessing The datasets were preprocessed as follows: The summary was tokenized with the [google/mt5-small](https://huggingface.co/google/mt5-small) tokenizer. Then only the records with no more than 94 summary tokens were selected. The MLSUM dataset has a special characteristic. In the text, the summary is often included completely as one or more sentences. These have been removed from the texts. The reason is that we do not want to train a model that ultimately extracts only sentences as a summary. This model is trained on the following datasets: | Name | Language | Size | License |------|----------|------|-------- | [CNN Daily - Train](https://github.com/abisee/cnn-dailymail) | en | 218,223 | The license is unclear. The data comes from CNN and Daily Mail. We assume that it may only be used for research purposes and not commercially. | [Extreme Summarization (XSum) - Train](https://github.com/EdinburghNLP/XSum) | en | 204,005 | The license is unclear. The data comes from BBC. We assume that it may only be used for research purposes and not commercially. | [wiki_lingua English](https://github.com/esdurmus/Wikilingua) | en | 130,331 | [Creative Commons CC BY-NC-SA 3.0 License](https://www.wikihow.com/wikiHow:Terms-of-Use) | [wiki_lingua German](https://github.com/esdurmus/Wikilingua) | de | 48,390 | [Creative Commons CC BY-NC-SA 3.0 License](https://www.wikihow.com/wikiHow:Terms-of-Use) | [MLSUM German - Train](https://github.com/ThomasScialom/MLSUM) | de | 218,043 | Usage of dataset is restricted to non-commercial research purposes only. Copyright belongs to the original copyright holders (see [here](https://github.com/ThomasScialom/MLSUM#mlsum)). | [SwissText 2019 - Train](https://www.swisstext.org/2019/shared-task/german-text-summarization-challenge.html) | de | 84,564 | The license is unclear. The data was published in the [German Text Summarization Challenge](https://www.swisstext.org/2019/shared-task/german-text-summarization-challenge.html). We assume that they may be used for research purposes and not commercially. | Language | Size |------|------ | German | 350,997 | English | 552,559 | Total | 903,556 ## Evaluation on MLSUM German Test Set (no beams) | Model | rouge1 | rouge2 | rougeL | rougeLsum |-------|--------|--------|--------|---------- | [ml6team/mt5-small-german-finetune-mlsum](https://huggingface.co/ml6team/mt5-small-german-finetune-mlsum) | 18.3607 | 5.3604 | 14.5456 | 16.1946 | **deutsche-telekom/mT5-small-sum-de-en-01 (this)** | **21.7336** | **7.2614** | **17.1323** | **19.3977** ## Evaluation on CNN Daily English Test Set (no beams) | Model | rouge1 | rouge2 | rougeL | rougeLsum |-------|--------|--------|--------|---------- | [sshleifer/distilbart-xsum-12-6](https://huggingface.co/sshleifer/distilbart-xsum-12-6) | 26.7664 | 8.8243 | 18.3703 | 23.2614 | [facebook/bart-large-xsum](https://huggingface.co/facebook/bart-large-xsum) | 28.5374 | 9.8565 | 19.4829 | 24.7364 | [mrm8488/t5-base-finetuned-summarize-news](https://huggingface.co/mrm8488/t5-base-finetuned-summarize-news) | 37.576 | 14.7389 | 24.0254 | 34.4634 | **deutsche-telekom/mT5-small-sum-de-en-01 (this)** | **37.6339** | **16.5317** | **27.1418** | **34.9951** ## Evaluation on Extreme Summarization (XSum) English Test Set (no beams) | Model | rouge1 | rouge2 | rougeL | rougeLsum |-------|--------|--------|--------|---------- | [mrm8488/t5-base-finetuned-summarize-news](https://huggingface.co/mrm8488/t5-base-finetuned-summarize-news) | 18.6204 | 3.535 | 12.3997 | 15.2111 | [facebook/bart-large-xsum](https://huggingface.co/facebook/bart-large-xsum) | 28.5374 | 9.8565 | 19.4829 | 24.7364 | deutsche-telekom/mT5-small-sum-de-en-01 (this) | 32.3416 | 10.6191 | 25.3799 | 25.3908 | [sshleifer/distilbart-xsum-12-6](https://huggingface.co/sshleifer/distilbart-xsum-12-6) | 44.2553 &clubs; | 21.4289 &clubs; | 36.2639 &clubs; | 36.2696 &clubs; &clubs;: These values seem to be unusually high. It could be that the test set was used in the training data. ## License Copyright (c) 2021 Philip May, Deutsche Telekom AG This work is licensed under the [Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0)](https://creativecommons.org/licenses/by-nc-sa/3.0/) license.
kredor/punctuate-all
d2b63af491274847502712c75a8943a456169125
2022-04-28T05:26:05.000Z
[ "pytorch", "xlm-roberta", "token-classification", "transformers", "autotrain_compatible" ]
token-classification
false
kredor
null
kredor/punctuate-all
598
null
transformers
2,165
This is based on [Oliver Guhr's work](https://huggingface.co/oliverguhr/fullstop-punctuation-multilang-large). The difference is that it is a finetuned xlm-roberta-base instead of an xlm-roberta-large and on twelve languages instead of four. The languages are: English, German, French, Spanish, Bulgarian, Italian, Polish, Dutch, Czech, Portugese, Slovak, Slovenian. ----- report ----- precision recall f1-score support 0 0.99 0.99 0.99 73317475 . 0.94 0.95 0.95 4484845 , 0.86 0.86 0.86 6100650 ? 0.88 0.85 0.86 136479 - 0.60 0.29 0.39 233630 : 0.71 0.49 0.58 152424 accuracy 0.98 84425503 macro avg 0.83 0.74 0.77 84425503 weighted avg 0.98 0.98 0.98 84425503 ----- confusion matrix ----- t/p 0 . , ? - : 0 1.0 0.0 0.0 0.0 0.0 0.0 . 0.0 1.0 0.0 0.0 0.0 0.0 , 0.1 0.0 0.9 0.0 0.0 0.0 ? 0.0 0.1 0.0 0.8 0.0 0.0 - 0.1 0.1 0.5 0.0 0.3 0.0 : 0.0 0.3 0.1 0.0 0.0 0.5
sentence-transformers/bert-large-nli-mean-tokens
321b149057b64563bfc7bd2b2fb7d685ea9e4014
2022-06-15T22:16:03.000Z
[ "pytorch", "tf", "jax", "bert", "feature-extraction", "arxiv:1908.10084", "sentence-transformers", "sentence-similarity", "transformers", "license:apache-2.0" ]
sentence-similarity
false
sentence-transformers
null
sentence-transformers/bert-large-nli-mean-tokens
597
null
sentence-transformers
2,166
--- pipeline_tag: sentence-similarity tags: - sentence-transformers - feature-extraction - sentence-similarity - transformers license: apache-2.0 --- **⚠️ This model is deprecated. Please don't use it as it produces sentence embeddings of low quality. You can find recommended sentence embedding models here: [SBERT.net - Pretrained Models](https://www.sbert.net/docs/pretrained_models.html)** # sentence-transformers/bert-large-nli-mean-tokens This is a [sentence-transformers](https://www.SBERT.net) model: It maps sentences & paragraphs to a 1024 dimensional dense vector space and can be used for tasks like clustering or semantic search. ## Usage (Sentence-Transformers) Using this model becomes easy when you have [sentence-transformers](https://www.SBERT.net) installed: ``` pip install -U sentence-transformers ``` Then you can use the model like this: ```python from sentence_transformers import SentenceTransformer sentences = ["This is an example sentence", "Each sentence is converted"] model = SentenceTransformer('sentence-transformers/bert-large-nli-mean-tokens') embeddings = model.encode(sentences) print(embeddings) ``` ## Usage (HuggingFace Transformers) Without [sentence-transformers](https://www.SBERT.net), you can use the model like this: First, you pass your input through the transformer model, then you have to apply the right pooling-operation on-top of the contextualized word embeddings. ```python from transformers import AutoTokenizer, AutoModel import torch #Mean Pooling - Take attention mask into account for correct averaging def mean_pooling(model_output, attention_mask): token_embeddings = model_output[0] #First element of model_output contains all token embeddings input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float() return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9) # Sentences we want sentence embeddings for sentences = ['This is an example sentence', 'Each sentence is converted'] # Load model from HuggingFace Hub tokenizer = AutoTokenizer.from_pretrained('sentence-transformers/bert-large-nli-mean-tokens') model = AutoModel.from_pretrained('sentence-transformers/bert-large-nli-mean-tokens') # Tokenize sentences encoded_input = tokenizer(sentences, padding=True, truncation=True, return_tensors='pt') # Compute token embeddings with torch.no_grad(): model_output = model(**encoded_input) # Perform pooling. In this case, max pooling. sentence_embeddings = mean_pooling(model_output, encoded_input['attention_mask']) print("Sentence embeddings:") print(sentence_embeddings) ``` ## Evaluation Results For an automated evaluation of this model, see the *Sentence Embeddings Benchmark*: [https://seb.sbert.net](https://seb.sbert.net?model_name=sentence-transformers/bert-large-nli-mean-tokens) ## Full Model Architecture ``` SentenceTransformer( (0): Transformer({'max_seq_length': 128, 'do_lower_case': False}) with Transformer model: BertModel (1): Pooling({'word_embedding_dimension': 1024, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False}) ) ``` ## Citing & Authors This model was trained by [sentence-transformers](https://www.sbert.net/). If you find this model helpful, feel free to cite our publication [Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks](https://arxiv.org/abs/1908.10084): ```bibtex @inproceedings{reimers-2019-sentence-bert, title = "Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks", author = "Reimers, Nils and Gurevych, Iryna", booktitle = "Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing", month = "11", year = "2019", publisher = "Association for Computational Linguistics", url = "http://arxiv.org/abs/1908.10084", } ```
dandelin/vilt-b32-finetuned-coco
2f3f7f3f62a3f4f429c26309256485bbd9b0e40a
2022-01-23T09:45:24.000Z
[ "pytorch", "vilt", "arxiv:2102.03334", "transformers", "license:apache-2.0" ]
null
false
dandelin
null
dandelin/vilt-b32-finetuned-coco
595
null
transformers
2,167
--- license: apache-2.0 --- # Vision-and-Language Transformer (ViLT), fine-tuned on COCO Vision-and-Language Transformer (ViLT) model fine-tuned on [COCO](https://cocodataset.org/#home). It was introduced in the paper [ViLT: Vision-and-Language Transformer Without Convolution or Region Supervision](https://arxiv.org/abs/2102.03334) by Kim et al. and first released in [this repository](https://github.com/dandelin/ViLT). Disclaimer: The team releasing ViLT did not write a model card for this model so this model card has been written by the Hugging Face team. ## Intended uses & limitations You can use the model for image and text retrieval. ### How to use Here is how to use the model in PyTorch: ``` from transformers import ViltProcessor, ViltForImageAndTextRetrieval import requests from PIL import Image url = "http://images.cocodataset.org/val2017/000000039769.jpg" image = Image.open(requests.get(url, stream=True).raw) texts = ["An image of two cats chilling on a couch", "A football player scoring a goal"] processor = ViltProcessor.from_pretrained("dandelin/vilt-b32-finetuned-coco") model = ViltForImageAndTextRetrieval.from_pretrained("dandelin/vilt-b32-finetuned-coco") # prepare inputs encoding = processor(image, text, return_tensors="pt") # forward pass scores = dict() for text in texts: encoding = processor(image, text, return_tensors="pt") outputs = model(**encoding) scores[text] = outputs.logits[0, :].item() ``` ## Training data (to do) ## Training procedure ### Preprocessing (to do) ### Pretraining (to do) ## Evaluation results (to do) ### BibTeX entry and citation info ```bibtex @misc{kim2021vilt, title={ViLT: Vision-and-Language Transformer Without Convolution or Region Supervision}, author={Wonjae Kim and Bokyung Son and Ildoo Kim}, year={2021}, eprint={2102.03334}, archivePrefix={arXiv}, primaryClass={stat.ML} } ```
bvanaken/CORe-clinical-outcome-biobert-v1
f57bd8bae74a778058b1d2d45ce4ea12bc806b7e
2021-05-19T13:34:58.000Z
[ "pytorch", "jax", "bert", "en", "transformers", "medical", "clinical" ]
null
false
bvanaken
null
bvanaken/CORe-clinical-outcome-biobert-v1
594
3
transformers
2,168
--- language: "en" tags: - bert - medical - clinical thumbnail: "https://core.app.datexis.com/static/paper.png" --- # CORe Model - BioBERT + Clinical Outcome Pre-Training ## Model description The CORe (_Clinical Outcome Representations_) model is introduced in the paper [Clinical Outcome Predictions from Admission Notes using Self-Supervised Knowledge Integration](https://www.aclweb.org/anthology/2021.eacl-main.75.pdf). It is based on BioBERT and further pre-trained on clinical notes, disease descriptions and medical articles with a specialised _Clinical Outcome Pre-Training_ objective. #### How to use CORe You can load the model via the transformers library: ``` from transformers import AutoTokenizer, AutoModel tokenizer = AutoTokenizer.from_pretrained("bvanaken/CORe-clinical-outcome-biobert-v1") model = AutoModel.from_pretrained("bvanaken/CORe-clinical-outcome-biobert-v1") ``` From there, you can fine-tune it on clinical tasks that benefit from patient outcome knowledge. ### Pre-Training Data The model is based on [BioBERT](https://huggingface.co/dmis-lab/biobert-v1.1) pre-trained on PubMed data. The _Clinical Outcome Pre-Training_ included discharge summaries from the MIMIC III training set (specified [here](https://github.com/bvanaken/clinical-outcome-prediction/blob/master/tasks/mimic_train.csv)), medical transcriptions from [MTSamples](https://mtsamples.com/) and clinical notes from the i2b2 challenges 2006-2012. It further includes ~10k case reports from PubMed Central (PMC), disease articles from Wikipedia and article sections from the [MedQuAd](https://github.com/abachaa/MedQuAD) dataset extracted from NIH websites. ### More Information For all the details about CORe and contact info, please visit [CORe.app.datexis.com](http://core.app.datexis.com/). ### Cite ```bibtex @inproceedings{vanaken21, author = {Betty van Aken and Jens-Michalis Papaioannou and Manuel Mayrdorfer and Klemens Budde and Felix A. Gers and Alexander Löser}, title = {Clinical Outcome Prediction from Admission Notes using Self-Supervised Knowledge Integration}, booktitle = {Proceedings of the 16th Conference of the European Chapter of the Association for Computational Linguistics: Main Volume, {EACL} 2021, Online, April 19 - 23, 2021}, publisher = {Association for Computational Linguistics}, year = {2021}, } ```
daveni/twitter-xlm-roberta-emotion-es
ab57a1137b2eb1f6c90fc77b0a4c4ced7dbd4d60
2022-04-28T09:49:06.000Z
[ "pytorch", "xlm-roberta", "text-classification", "es", "transformers", "Emotion Analysis" ]
text-classification
false
daveni
null
daveni/twitter-xlm-roberta-emotion-es
594
2
transformers
2,169
--- language: - es tags: - Emotion Analysis --- **Note**: This model & model card are based on the [finetuned XLM-T for Sentiment Analysis](https://huggingface.co/cardiffnlp/twitter-xlm-roberta-base-sentiment) # twitter-XLM-roBERTa-base for Emotion Analysis This is a XLM-roBERTa-base model trained on ~198M tweets and finetuned for emotion analysis on Spanish language. This model was presented to EmoEvalEs competition, part of [IberLEF 2021 Conference](https://sites.google.com/view/iberlef2021/), where the proposed task was the classification of Spanish tweets between seven different classes: *anger*, *disgust*, *fear*, *joy*, *sadness*, *surprise*, and *other*. We achieved the first position in the competition with a macro-averaged F1 score of 71.70%. - [Our code for EmoEvalEs submission](https://github.com/gsi-upm/emoevales-iberlef2021). - [EmoEvalEs Dataset](https://github.com/pendrag/EmoEvalEs) ## Example Pipeline with a [Tweet from @JaSantaolalla](https://twitter.com/JaSantaolalla/status/1398383243645177860) ```python from transformers import pipeline model_path = "daveni/twitter-xlm-roberta-emotion-es" emotion_analysis = pipeline("text-classification", framework="pt", model=model_path, tokenizer=model_path) emotion_analysis("Einstein dijo: Solo hay dos cosas infinitas, el universo y los pinches anuncios de bitcoin en Twitter. Paren ya carajo aaaaaaghhgggghhh me quiero murir") ``` ``` [{'label': 'anger', 'score': 0.48307016491889954}] ``` ## Full classification example ```python from transformers import AutoModelForSequenceClassification from transformers import AutoTokenizer, AutoConfig import numpy as np from scipy.special import softmax # Preprocess text (username and link placeholders) def preprocess(text): new_text = [] for t in text.split(" "): t = '@user' if t.startswith('@') and len(t) > 1 else t t = 'http' if t.startswith('http') else t new_text.append(t) return " ".join(new_text) model_path = "daveni/twitter-xlm-roberta-emotion-es" tokenizer = AutoTokenizer.from_pretrained(model_path ) config = AutoConfig.from_pretrained(model_path ) # PT model = AutoModelForSequenceClassification.from_pretrained(model_path ) text = "Se ha quedao bonito día para publicar vídeo, ¿no? Hoy del tema más diferente que hemos tocado en el canal." text = preprocess(text) print(text) encoded_input = tokenizer(text, return_tensors='pt') output = model(**encoded_input) scores = output[0][0].detach().numpy() scores = softmax(scores) # Print labels and scores ranking = np.argsort(scores) ranking = ranking[::-1] for i in range(scores.shape[0]): l = config.id2label[ranking[i]] s = scores[ranking[i]] print(f"{i+1}) {l} {np.round(float(s), 4)}") ``` Output: ``` Se ha quedao bonito día para publicar vídeo, ¿no? Hoy del tema más diferente que hemos tocado en el canal. 1) joy 0.7887 2) others 0.1679 3) surprise 0.0152 4) sadness 0.0145 5) anger 0.0077 6) disgust 0.0033 7) fear 0.0027 ``` #### Limitations and bias - The dataset we used for finetuning was unbalanced, where almost half of the records belonged to the *other* class so there might be bias towards this class. ## Training data Pretrained weights were left identical to the original model released by [cardiffnlp](https://huggingface.co/cardiffnlp/twitter-xlm-roberta-base). We used the [EmoEvalEs Dataset](https://github.com/pendrag/EmoEvalEs) for finetuning. ### BibTeX entry and citation info ```bibtex @inproceedings{vera2021gsi, title={GSI-UPM at IberLEF2021: Emotion Analysis of Spanish Tweets by Fine-tuning the XLM-RoBERTa Language Model}, author={Vera, D and Araque, O and Iglesias, CA}, booktitle={Proceedings of the Iberian Languages Evaluation Forum (IberLEF 2021). CEUR Workshop Proceedings, CEUR-WS, M{\'a}laga, Spain}, year={2021} } ```
felinecity/DioloGPT-small-KaeyaBot
5a337d5e71543801846df24610e39d3234e0c4e0
2022-01-13T00:34:48.000Z
[ "pytorch", "gpt2", "text-generation", "transformers", "conversational" ]
conversational
false
felinecity
null
felinecity/DioloGPT-small-KaeyaBot
594
null
transformers
2,170
--- tags: - conversational --- # DioloGPT KaeyaBot model
textattack/roberta-base-RTE
de14c050a0da06785eec4c151b1778cb1d111d0a
2021-05-20T22:10:37.000Z
[ "pytorch", "jax", "roberta", "text-classification", "transformers" ]
text-classification
false
textattack
null
textattack/roberta-base-RTE
594
null
transformers
2,171
## TextAttack Model Card This `roberta-base` model was fine-tuned for sequence classification using TextAttack and the glue dataset loaded using the `nlp` library. The model was fine-tuned for 5 epochs with a batch size of 16, a learning rate of 2e-05, and a maximum sequence length of 128. Since this was a classification task, the model was trained with a cross-entropy loss function. The best score the model achieved on this task was 0.7942238267148014, as measured by the eval set accuracy, found after 3 epochs. For more information, check out [TextAttack on Github](https://github.com/QData/TextAttack).
KoboldAI/GPT-Neo-2.7B-Picard
3a960ae005ab3af21278572dee45b5efdf0ffc27
2022-03-20T13:02:38.000Z
[ "pytorch", "gpt_neo", "text-generation", "en", "transformers", "license:mit" ]
text-generation
false
KoboldAI
null
KoboldAI/GPT-Neo-2.7B-Picard
593
3
transformers
2,172
--- language: en license: mit --- # GPT-Neo 2.7B - Picard ## Model Description GPT-Neo 2.7B-Picard is a finetune created using EleutherAI's GPT-Neo 2.7B model. ## Training data The training data contains around 1800 ebooks, mostly in the sci-fi and fantasy genres. ### How to use You can use this model directly with a pipeline for text generation. This example generates a different sequence each time it's run: ```py >>> from transformers import pipeline >>> generator = pipeline('text-generation', model='mrseeker87/GPT-Neo-2.7B-Picard') >>> generator("Jean-Luc Picard", do_sample=True, min_length=50) [{'generated_text': 'Jean-Luc Picard, the captain of a Federation starship in command of one of Starfleet's few fulltime scientists.'}] ``` ### Limitations and Biases GPT-Neo was trained as an autoregressive language model. This means that its core functionality is taking a string of text and predicting the next token. While language models are widely used for tasks other than this, there are a lot of unknowns with this work. GPT-Neo was trained on the Pile, a dataset known to contain profanity, lewd, and otherwise abrasive language. Depending on your usecase GPT-Neo may produce socially unacceptable text. See Sections 5 and 6 of the Pile paper for a more detailed analysis of the biases in the Pile. As with all language models, it is hard to predict in advance how GPT-Neo will respond to particular prompts and offensive content may occur without warning. We recommend having a human curate or filter the outputs before releasing them, both to censor undesirable content and to improve the quality of the results. ### BibTeX entry and citation info The model is made using the following software: ```bibtex @software{gpt-neo, author = {Black, Sid and Leo, Gao and Wang, Phil and Leahy, Connor and Biderman, Stella}, title = {{GPT-Neo: Large Scale Autoregressive Language Modeling with Mesh-Tensorflow}}, month = mar, year = 2021, note = {{If you use this software, please cite it using these metadata.}}, publisher = {Zenodo}, version = {1.0}, doi = {10.5281/zenodo.5297715}, url = {https://doi.org/10.5281/zenodo.5297715} } ```
chambliss/distilbert-for-food-extraction
d7d194fb9c2ce6ea36b80be0133d331f58532980
2020-10-14T21:58:56.000Z
[ "pytorch", "tf", "distilbert", "token-classification", "transformers", "autotrain_compatible" ]
token-classification
false
chambliss
null
chambliss/distilbert-for-food-extraction
593
1
transformers
2,173
Entry not found
mrm8488/bert-mini-5-finetuned-squadv2
7c240aba1471ad8f37798ded3aeff8fdd664d09d
2021-05-20T00:25:56.000Z
[ "pytorch", "jax", "bert", "question-answering", "transformers", "autotrain_compatible" ]
question-answering
false
mrm8488
null
mrm8488/bert-mini-5-finetuned-squadv2
593
null
transformers
2,174
Entry not found
amine/bert-base-5lang-cased
c2df409a7019fdead7fe7a21eda2338cb475e73f
2021-05-18T23:35:02.000Z
[ "pytorch", "tf", "jax", "bert", "fill-mask", "en", "fr", "es", "de", "zh", "dataset:wikipedia", "transformers", "multilingual", "license:apache-2.0", "autotrain_compatible" ]
fill-mask
false
amine
null
amine/bert-base-5lang-cased
592
null
transformers
2,175
--- language: - en - fr - es - de - zh tags: - pytorch - bert - multilingual - en - fr - es - de - zh datasets: wikipedia license: apache-2.0 inference: false --- # bert-base-5lang-cased This is a smaller version of [bert-base-multilingual-cased](https://huggingface.co/bert-base-multilingual-cased) that handles only 5 languages (en, fr, es, de and zh) instead of 104. The model is therefore 30% smaller than the original one (124M parameters instead of 178M) but gives exactly the same representations for the above cited languages. Starting from `bert-base-5lang-cased` will facilitate the deployment of your model on public cloud platforms while keeping similar results. For instance, Google Cloud Platform requires that the model size on disk should be lower than 500 MB for serveless deployments (Cloud Functions / Cloud ML) which is not the case of the original `bert-base-multilingual-cased`. For more information about the models size, memory footprint and loading time please refer to the table below: | Model | Num parameters | Size | Memory | Loading time | | ---------------------------- | -------------- | -------- | -------- | ------------ | | bert-base-multilingual-cased | 178 million | 714 MB | 1400 MB | 4.2 sec | | bert-base-5lang-cased | 124 million | 495 MB | 950 MB | 3.6 sec | These measurements have been computed on a [Google Cloud n1-standard-1 machine (1 vCPU, 3.75 GB)](https://cloud.google.com/compute/docs/machine-types\#n1_machine_type). ## How to use ```python from transformers import AutoTokenizer, AutoModel tokenizer = AutoTokenizer.from_pretrained("amine/bert-base-5lang-cased") model = AutoModel.from_pretrained("amine/bert-base-5lang-cased") ``` ### How to cite ```bibtex @inproceedings{smallermbert, title={Load What You Need: Smaller Versions of Multilingual BERT}, author={Abdaoui, Amine and Pradel, Camille and Sigel, Grégoire}, booktitle={SustaiNLP / EMNLP}, year={2020} } ``` ## Contact Please contact [email protected] for any question, feedback or request.
cointegrated/rubert-tiny-sentiment-balanced
0156ad2feebc300b208a5c120330a771f28a9af5
2021-08-29T11:34:44.000Z
[ "pytorch", "bert", "text-classification", "ru", "transformers", "russian", "classification", "sentiment", "multiclass" ]
text-classification
false
cointegrated
null
cointegrated/rubert-tiny-sentiment-balanced
592
null
transformers
2,176
--- language: ["ru"] tags: - russian - classification - sentiment - multiclass widget: - text: "Какая гадость эта ваша заливная рыба!" --- This is the [cointegrated/rubert-tiny](https://huggingface.co/cointegrated/rubert-tiny) model fine-tuned for classification of sentiment for short Russian texts. The problem is formulated as multiclass classification: `negative` vs `neutral` vs `positive`. ## Usage The function below estimates the sentiment of the given text: ```python # !pip install transformers sentencepiece --quiet import torch from transformers import AutoTokenizer, AutoModelForSequenceClassification model_checkpoint = 'cointegrated/rubert-tiny-sentiment-balanced' tokenizer = AutoTokenizer.from_pretrained(model_checkpoint) model = AutoModelForSequenceClassification.from_pretrained(model_checkpoint) if torch.cuda.is_available(): model.cuda() def get_sentiment(text, return_type='label'): """ Calculate sentiment of a text. `return_type` can be 'label', 'score' or 'proba' """ with torch.no_grad(): inputs = tokenizer(text, return_tensors='pt', truncation=True, padding=True).to(model.device) proba = torch.sigmoid(model(**inputs).logits).cpu().numpy()[0] if return_type == 'label': return model.config.id2label[proba.argmax()] elif return_type == 'score': return proba.dot([-1, 0, 1]) return proba text = 'Какая гадость эта ваша заливная рыба!' # classify the text print(get_sentiment(text, 'label')) # negative # score the text on the scale from -1 (very negative) to +1 (very positive) print(get_sentiment(text, 'score')) # -0.5894946306943893 # calculate probabilities of all labels print(get_sentiment(text, 'proba')) # [0.7870447 0.4947824 0.19755007] ``` ## Training We trained the model on [the datasets collected by Smetanin](https://github.com/sismetanin/sentiment-analysis-in-russian). We have converted all training data into a 3-class format and have up- and downsampled the training data to balance both the sources and the classes. The training code is available as [a Colab notebook](https://gist.github.com/avidale/e678c5478086c1d1adc52a85cb2b93e6). The metrics on the balanced test set are the following: | Source | Macro F1 | | ----------- | ----------- | | SentiRuEval2016_banks | 0.83 | | SentiRuEval2016_tele | 0.74 | | kaggle_news | 0.66 | | linis | 0.50 | | mokoron | 0.98 | | rureviews | 0.72 | | rusentiment | 0.67 |
flair/ner-german-legal
ec83b13d1cc3f462c671dec3acef1aeb4e2a9ea3
2021-02-26T15:40:55.000Z
[ "pytorch", "de", "dataset:legal", "flair", "token-classification", "sequence-tagger-model" ]
token-classification
false
flair
null
flair/ner-german-legal
591
null
flair
2,177
--- tags: - flair - token-classification - sequence-tagger-model language: de datasets: - legal widget: - text: "Herr W. verstieß gegen § 36 Abs. 7 IfSG." --- ## NER for German Legal Text in Flair (default model) This is the legal NER model for German that ships with [Flair](https://github.com/flairNLP/flair/). F1-Score: **96,35** (LER German dataset) Predicts 19 tags: | **tag** | **meaning** | |---------------------------------|-----------| | AN | Anwalt | | EUN | Europäische Norm | | GS | Gesetz | | GRT | Gericht | | INN | Institution | | LD | Land | | LDS | Landschaft | | LIT | Literatur | | MRK | Marke | | ORG | Organisation | | PER | Person | | RR | Richter | | RS | Rechtssprechung | | ST | Stadt | | STR | Straße | | UN | Unternehmen | | VO | Verordnung | | VS | Vorschrift | | VT | Vertrag | Based on [Flair embeddings](https://www.aclweb.org/anthology/C18-1139/) and LSTM-CRF. More details on the Legal NER dataset [here](https://github.com/elenanereiss/Legal-Entity-Recognition) --- ### Demo: How to use in Flair Requires: **[Flair](https://github.com/flairNLP/flair/)** (`pip install flair`) ```python from flair.data import Sentence from flair.models import SequenceTagger # load tagger tagger = SequenceTagger.load("flair/ner-german-legal") # make example sentence (don't use tokenizer since Rechtstexte are badly handled) sentence = Sentence("Herr W. verstieß gegen § 36 Abs. 7 IfSG.", use_tokenizer=False) # predict NER tags tagger.predict(sentence) # print sentence print(sentence) # print predicted NER spans print('The following NER tags are found:') # iterate over entities and print for entity in sentence.get_spans('ner'): print(entity) ``` This yields the following output: ``` Span [2]: "W." [− Labels: PER (0.9911)] Span [5,6,7,8,9]: "§ 36 Abs. 7 IfSG." [− Labels: GS (0.5353)] ``` So, the entities "*W.*" (labeled as a **person**) and "*§ 36 Abs. 7 IfSG*" (labeled as a **Gesetz**) are found in the sentence "*Herr W. verstieß gegen § 36 Abs. 7 IfSG.*". --- ### Training: Script to train this model The following Flair script was used to train this model: ```python from flair.data import Corpus from flair.datasets import LER_GERMAN from flair.embeddings import WordEmbeddings, StackedEmbeddings, FlairEmbeddings # 1. get the corpus corpus: Corpus = LER_GERMAN() # 2. what tag do we want to predict? tag_type = 'ner' # 3. make the tag dictionary from the corpus tag_dictionary = corpus.make_tag_dictionary(tag_type=tag_type) # 4. initialize each embedding we use embedding_types = [ # GloVe embeddings WordEmbeddings('de'), # contextual string embeddings, forward FlairEmbeddings('de-forward'), # contextual string embeddings, backward FlairEmbeddings('de-backward'), ] # embedding stack consists of Flair and GloVe embeddings embeddings = StackedEmbeddings(embeddings=embedding_types) # 5. initialize sequence tagger from flair.models import SequenceTagger tagger = SequenceTagger(hidden_size=256, embeddings=embeddings, tag_dictionary=tag_dictionary, tag_type=tag_type) # 6. initialize trainer from flair.trainers import ModelTrainer trainer = ModelTrainer(tagger, corpus) # 7. run training trainer.train('resources/taggers/ner-german-legal', train_with_dev=True, max_epochs=150) ``` --- ### Cite Please cite the following papers when using this model. ``` @inproceedings{leitner2019fine, author = {Elena Leitner and Georg Rehm and Julian Moreno-Schneider}, title = {{Fine-grained Named Entity Recognition in Legal Documents}}, booktitle = {Semantic Systems. The Power of AI and Knowledge Graphs. Proceedings of the 15th International Conference (SEMANTiCS 2019)}, year = 2019, pages = {272--287}, pdf = {https://link.springer.com/content/pdf/10.1007%2F978-3-030-33220-4_20.pdf}} ``` ``` @inproceedings{akbik2018coling, title={Contextual String Embeddings for Sequence Labeling}, author={Akbik, Alan and Blythe, Duncan and Vollgraf, Roland}, booktitle = {{COLING} 2018, 27th International Conference on Computational Linguistics}, pages = {1638--1649}, year = {2018} } ``` --- ### Issues? The Flair issue tracker is available [here](https://github.com/flairNLP/flair/issues/).
sagorsarker/codeswitch-spaeng-lid-lince
f0385677c8f48242fc5b9d4d25d24b960cd2da1c
2021-06-11T04:12:00.000Z
[ "pytorch", "jax", "bert", "token-classification", "es", "en", "dataset:lince", "transformers", "codeswitching", "spanish-english", "language-identification", "license:mit", "autotrain_compatible" ]
token-classification
false
sagorsarker
null
sagorsarker/codeswitch-spaeng-lid-lince
591
null
transformers
2,178
--- language: - es - en datasets: - lince license: mit tags: - codeswitching - spanish-english - language-identification --- # codeswitch-spaeng-lid-lince This is a pretrained model for **language identification** of `spanish-english` code-mixed data used from [LinCE](https://ritual.uh.edu/lince/home) This model is trained for this below repository. [https://github.com/sagorbrur/codeswitch](https://github.com/sagorbrur/codeswitch) To install codeswitch: ``` pip install codeswitch ``` ## Identify Language * **Method-1** ```py from codeswitch.codeswitch import LanguageIdentification lid = LanguageIdentification('spa-eng') text = "" # your code-mixed sentence result = lid.identify(text) print(result) ``` * **Method-2** ```py from transformers import AutoTokenizer, AutoModelForTokenClassification, pipeline tokenizer = AutoTokenizer.from_pretrained("sagorsarker/codeswitch-spaeng-lid-lince") model = AutoModelForTokenClassification.from_pretrained("sagorsarker/codeswitch-spaeng-lid-lince") lid_model = pipeline('ner', model=model, tokenizer=tokenizer) lid_model("put any spanish english code-mixed sentence") ```
mmillet/distilrubert-tiny-2ndfinetune-epru
3e985055f16fc805358a9065b6be4f116807720e
2022-06-10T20:46:22.000Z
[ "pytorch", "tensorboard", "distilbert", "text-classification", "transformers", "generated_from_trainer", "model-index" ]
text-classification
false
mmillet
null
mmillet/distilrubert-tiny-2ndfinetune-epru
590
null
transformers
2,179
--- tags: - generated_from_trainer metrics: - accuracy - f1 - precision - recall model-index: - name: distilrubert-tiny-2ndfinetune-epru 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. --> # distilrubert-tiny-2ndfinetune-epru This model is a fine-tuned version of [mmillet/distilrubert-tiny-cased-conversational-v1_single_finetuned_on_cedr_augmented](https://huggingface.co/mmillet/distilrubert-tiny-cased-conversational-v1_single_finetuned_on_cedr_augmented) on an unknown dataset. It achieves the following results on the evaluation set: - Loss: 0.2085 - Accuracy: 0.9333 - F1: 0.9319 - Precision: 0.9336 - Recall: 0.9333 ## Model description More information needed ## Intended uses & limitations More information needed ## Training and evaluation data More information needed ## Training procedure ### Training hyperparameters The following hyperparameters were used during training: - learning_rate: 0.0001 - train_batch_size: 64 - eval_batch_size: 64 - seed: 42 - optimizer: Adam with betas=(0.9,0.999) and epsilon=1e-06 - lr_scheduler_type: linear - num_epochs: 20 ### Training results | Training Loss | Epoch | Step | Validation Loss | Accuracy | F1 | Precision | Recall | |:-------------:|:-----:|:----:|:---------------:|:--------:|:------:|:---------:|:------:| | 0.4825 | 1.0 | 13 | 0.2988 | 0.8848 | 0.8827 | 0.9056 | 0.8848 | | 0.2652 | 2.0 | 26 | 0.2435 | 0.9212 | 0.9216 | 0.9282 | 0.9212 | | 0.168 | 3.0 | 39 | 0.2120 | 0.9515 | 0.9501 | 0.9524 | 0.9515 | | 0.1593 | 4.0 | 52 | 0.1962 | 0.9333 | 0.9330 | 0.9366 | 0.9333 | | 0.1294 | 5.0 | 65 | 0.1855 | 0.9333 | 0.9334 | 0.9355 | 0.9333 | | 0.1065 | 6.0 | 78 | 0.1780 | 0.9394 | 0.9393 | 0.9399 | 0.9394 | | 0.0908 | 7.0 | 91 | 0.1967 | 0.9394 | 0.9388 | 0.9388 | 0.9394 | | 0.0432 | 8.0 | 104 | 0.2085 | 0.9333 | 0.9319 | 0.9336 | 0.9333 | ### Framework versions - Transformers 4.19.3 - Pytorch 1.11.0+cu113 - Datasets 2.2.2 - Tokenizers 0.12.1
dbmdz/electra-base-turkish-cased-discriminator
9659a044cd77c80b7d5aea7864758543af141903
2020-12-11T21:37:26.000Z
[ "pytorch", "tf", "electra", "pretraining", "tr", "transformers", "license:mit" ]
null
false
dbmdz
null
dbmdz/electra-base-turkish-cased-discriminator
589
null
transformers
2,180
--- language: tr license: mit --- # 🤗 + 📚 dbmdz Turkish ELECTRA model In this repository the MDZ Digital Library team (dbmdz) at the Bavarian State Library open sources a cased ELECTRA base model for Turkish 🎉 # Turkish ELECTRA model We release a base ELEC**TR**A model for Turkish, that was trained on the same data as *BERTurk*. > ELECTRA is a new method for self-supervised language representation learning. It can be used to > pre-train transformer networks using relatively little compute. ELECTRA models are trained to > distinguish "real" input tokens vs "fake" input tokens generated by another neural network, similar to > the discriminator of a GAN. More details about ELECTRA can be found in the [ICLR paper](https://openreview.net/forum?id=r1xMH1BtvB) or in the [official ELECTRA repository](https://github.com/google-research/electra) on GitHub. ## Stats The current version of the model is trained on a filtered and sentence segmented version of the Turkish [OSCAR corpus](https://traces1.inria.fr/oscar/), a recent Wikipedia dump, various [OPUS corpora](http://opus.nlpl.eu/) and a special corpus provided by [Kemal Oflazer](http://www.andrew.cmu.edu/user/ko/). The final training corpus has a size of 35GB and 44,04,976,662 tokens. Thanks to Google's TensorFlow Research Cloud (TFRC) we could train a cased model on a TPU v3-8 for 1M steps. ## Model weights [Transformers](https://github.com/huggingface/transformers) compatible weights for both PyTorch and TensorFlow are available. | Model | Downloads | ------------------------------------------------ | --------------------------------------------------------------------------------------------------------------- | `dbmdz/electra-base-turkish-cased-discriminator` | [`config.json`](https://cdn.huggingface.co/dbmdz/electra-base-turkish-cased-discriminator/config.json) • [`pytorch_model.bin`](https://cdn.huggingface.co/dbmdz/electra-base-turkish-cased-discriminator/pytorch_model.bin) • [`vocab.txt`](https://cdn.huggingface.co/dbmdz/electra-base-turkish-cased-discriminator/vocab.txt) ## Usage With Transformers >= 2.8 our ELECTRA base cased model can be loaded like: ```python from transformers import AutoModelWithLMHead, AutoTokenizer tokenizer = AutoTokenizer.from_pretrained("dbmdz/electra-base-turkish-cased-discriminator") model = AutoModelWithLMHead.from_pretrained("dbmdz/electra-base-turkish-cased-discriminator") ``` ## Results For results on PoS tagging or NER tasks, please refer to [this repository](https://github.com/stefan-it/turkish-bert/electra). # Huggingface model hub All models are available on the [Huggingface model hub](https://huggingface.co/dbmdz). # Contact (Bugs, Feedback, Contribution and more) For questions about our ELECTRA models just open an issue [here](https://github.com/dbmdz/berts/issues/new) 🤗 # Acknowledgments Thanks to [Kemal Oflazer](http://www.andrew.cmu.edu/user/ko/) for providing us additional large corpora for Turkish. Many thanks to Reyyan Yeniterzi for providing us the Turkish NER dataset for evaluation. Research supported with Cloud TPUs from Google's TensorFlow Research Cloud (TFRC). Thanks for providing access to the TFRC ❤️ Thanks to the generous support from the [Hugging Face](https://huggingface.co/) team, it is possible to download both cased and uncased models from their S3 storage 🤗
razent/SciFive-large-Pubmed_PMC-MedNLI
99fffdb01c4d30f6289090ae2d2ce4f5b7bc4970
2022-03-22T04:05:21.000Z
[ "pytorch", "tf", "t5", "text2text-generation", "en", "dataset:pubmed", "dataset:pmc/open_access", "arxiv:2106.03598", "transformers", "mednli", "autotrain_compatible" ]
text2text-generation
false
razent
null
razent/SciFive-large-Pubmed_PMC-MedNLI
589
1
transformers
2,181
--- language: - en tags: - text2text-generation - mednli datasets: - pubmed - pmc/open_access widget: - text: "mednli: sentence1: In the ED, initial VS revealed T 98.9, HR 73, BP 121/90, RR 15, O2 sat 98% on RA. sentence2: The patient is hemodynamically stable" --- # SciFive Pubmed+PMC Large on MedNLI ## Introduction Finetuned SciFive Pubmed+PMC Large model achieved state-of-the-art results on [MedNLI (Medical Natural Language Inference)](https://paperswithcode.com/sota/natural-language-inference-on-mednli) Paper: [SciFive: a text-to-text transformer model for biomedical literature](https://arxiv.org/abs/2106.03598) Authors: _Long N. Phan, James T. Anibal, Hieu Tran, Shaurya Chanana, Erol Bahadroglu, Alec Peltekian, Grégoire Altan-Bonnet_ ## How to use For more details, do check out [our Github repo](https://github.com/justinphan3110/SciFive). ```python from transformers import AutoTokenizer, AutoModelForSeq2SeqLM ​ tokenizer = AutoTokenizer.from_pretrained("razent/SciFive-large-Pubmed_PMC-MedNLI") model = AutoModelForSeq2SeqLM.from_pretrained("razent/SciFive-large-Pubmed_PMC-MedNLI") model.cuda() ​ sent_1 = "In the ED, initial VS revealed T 98.9, HR 73, BP 121/90, RR 15, O2 sat 98% on RA." sent_2 = "The patient is hemodynamically stable" text = f"mednli: sentence1: {sent_1} sentence2: {sent_2}" encoding = tokenizer.encode_plus(text, padding='max_length', max_length=256, return_tensors="pt") input_ids, attention_masks = encoding["input_ids"].to("cuda"), encoding["attention_mask"].to("cuda") outputs = model.generate( input_ids=input_ids, attention_mask=attention_masks, max_length=8, early_stopping=True ) for output in outputs: line = tokenizer.decode(output, skip_special_tokens=True, clean_up_tokenization_spaces=True) print(line) ```
xlm-mlm-tlm-xnli15-1024
79f909ec8d0e5b3ed19940f85fccb2bb2d028f6c
2022-07-22T08:10:34.000Z
[ "pytorch", "tf", "xlm", "fill-mask", "multilingual", "en", "fr", "es", "de", "el", "bg", "ru", "tr", "ar", "vi", "th", "zh", "hi", "sw", "ur", "arxiv:1901.07291", "arxiv:1910.09700", "transformers", "license:cc-by-nc-4.0", "autotrain_compatible" ]
fill-mask
false
null
null
xlm-mlm-tlm-xnli15-1024
587
null
transformers
2,182
--- language: - multilingual - en - fr - es - de - el - bg - ru - tr - ar - vi - th - zh - hi - sw - ur license: cc-by-nc-4.0 --- # xlm-mlm-tlm-xnli15-1024 # Table of Contents 1. [Model Details](#model-details) 2. [Uses](#uses) 3. [Bias, Risks, and Limitations](#bias-risks-and-limitations) 4. [Training Details](#training-details) 5. [Evaluation](#evaluation) 6. [Environmental Impact](#environmental-impact) 7. [Technical Specifications](#technical-specifications) 8. [Citation](#citation) 9. [Model Card Authors](#model-card-authors) 10. [How To Get Started With the Model](#how-to-get-started-with-the-model) # Model Details The XLM model was proposed in [Cross-lingual Language Model Pretraining](https://arxiv.org/abs/1901.07291) by Guillaume Lample, Alexis Conneau. xlm-mlm-tlm-xnli15-1024 is a transformer pretrained using a masked language modeling (MLM) objective in combination with a translation language modeling (TLM) objective and then fine-tuned on the English NLI dataset. The model developers evaluated the capacity of the model to make correct predictions in all 15 XNLI languages (see the [XNLI data card](https://huggingface.co/datasets/xnli) for further information on XNLI). ## Model Description - **Developed by:** Guillaume Lample, Alexis Conneau, see [associated paper](https://arxiv.org/abs/1901.07291) - **Model type:** Language model - **Language(s) (NLP):** English; evaluated in 15 languages (see [XNLI data card](https://huggingface.co/datasets/xnli)) - **License:** CC-BY-NC-4.0 - **Related Models:** [XLM models](https://huggingface.co/models?sort=downloads&search=xlm) - **Resources for more information:** - [Associated paper](https://arxiv.org/abs/1901.07291) - [GitHub Repo for XLM](https://github.com/facebookresearch/XLM) - [GitHub Repo for XNLI](https://github.com/facebookresearch/XNLI) - [XNLI data card](https://huggingface.co/datasets/xnli) - [Hugging Face Multilingual Models for Inference docs](https://huggingface.co/docs/transformers/v4.20.1/en/multilingual#xlm-with-language-embeddings) # Uses ## Direct Use The model is a language model. The model can be used for cross-lingual text classification. Though the model is fine-tuned based on English text data, the model's ability to classify sentences in 14 other languages has been evaluated (see [Evaluation](#evaluation)). ## Downstream Use This model can be used for downstream tasks related to natural language inference in different languages. For more information, see the [associated paper](https://arxiv.org/abs/1901.07291). ## Out-of-Scope Use The model should not be used to intentionally create hostile or alienating environments for people. # Bias, Risks, and Limitations Significant research has explored bias and fairness issues with language models (see, e.g., [Sheng et al. (2021)](https://aclanthology.org/2021.acl-long.330.pdf) and [Bender et al. (2021)](https://dl.acm.org/doi/pdf/10.1145/3442188.3445922)). ## Recommendations Users (both direct and downstream) should be made aware of the risks, biases and limitations of the model. # Training Details Training details are culled from the [associated paper](https://arxiv.org/pdf/1901.07291.pdf). See the paper for links, citations, and further details. Also see the associated [GitHub Repo](https://github.com/facebookresearch/XLM#ii-cross-lingual-language-model-pretraining-xlm) for further details. ## Training Data The model developers write: > We use WikiExtractor2 to extract raw sentences from Wikipedia dumps and use them as mono-lingual data for the CLM and MLM objectives. For the TLM objective, we only use parallel data that involves English, similar to Conneau et al. (2018b). > - Precisely, we use MultiUN (Ziemski et al., 2016) for French, Spanish, Russian, Arabic and Chinese, and the IIT Bombay corpus (Anoop et al., 2018) for Hindi. > - We extract the following corpora from the OPUS 3 website Tiedemann (2012): the EUbookshop corpus for German, Greek and Bulgarian, OpenSubtitles 2018 for Turkish, Vietnamese and Thai, Tanzil for both Urdu and Swahili and GlobalVoices for Swahili. > - For Chinese, Japanese and Thai we use the tokenizer of Chang et al. (2008), the Kytea4 tokenizer, and the PyThaiNLP5 tokenizer respectively. > - For all other languages, we use the tokenizer provided by Moses (Koehn et al., 2007), falling back on the default English tokenizer when necessary. For fine-tuning, the developers used the English NLI dataset (see the [XNLI data card](https://huggingface.co/datasets/xnli)). ## Training Procedure ### Preprocessing The model developers write: > We use fastBPE to learn BPE codes and split words into subword units. The BPE codes are learned on the concatenation of sentences sampled from all languages, following the method presented in Section 3.1. ### Speeds, Sizes, Times The model developers write: > We use a Transformer architecture with 1024 hidden units, 8 heads, GELU activations (Hendrycks and Gimpel, 2016), a dropout rate of 0.1 and learned positional embeddings. We train our models with the Adam optimizer (Kingma and Ba, 2014), a linear warm-up (Vaswani et al., 2017) and learning rates varying from 10^−4 to 5.10^−4. > > For the CLM and MLM objectives, we use streams of 256 tokens and a mini-batches of size 64. Unlike Devlin et al. (2018), a sequence in a mini-batch can contain more than two consecutive sentences, as explained in Section 3.2. For the TLM objective, we sample mini-batches of 4000 tokens composed of sentences with similar lengths. We use the averaged perplexity over languages as a stopping criterion for training. For machine translation, we only use 6 layers, and we create mini-batches of 2000 tokens. > > When fine-tuning on XNLI, we use mini-batches of size 8 or 16, and we clip the sentence length to 256 words. We use 80k BPE splits and a vocabulary of 95k and train a 12-layer model on the Wikipedias of the XNLI languages. We sample the learning rate of the Adam optimizer with values from 5.10−4 to 2.10−4, and use small evaluation epochs of 20000 random samples. We use the first hidden state of the last layer of the transformer as input to the randomly initialized final linear classifier, and fine-tune all parameters. In our experiments, using either max-pooling or mean-pooling over the last layer did not work bet- ter than using the first hidden state. > > We implement all our models in Py-Torch (Paszke et al., 2017), and train them on 64 Volta GPUs for the language modeling tasks, and 8 GPUs for the MT tasks. We use float16 operations to speed up training and to reduce the memory usage of our models. # Evaluation ## Testing Data, Factors & Metrics After fine-tuning the model on the English NLI dataset, the model developers evaluated the capacity of the model to make correct predictions in the 15 XNLI languages using the XNLI data and the metric of test accuracy.See the [associated paper](https://arxiv.org/pdf/1901.07291.pdf) for further details. ## Results |Language| en | fr | es | de | el | bg | ru | tr | ar | vi | th | zh | hi | sw | ur | |:------:|:--:|:---:|:--:|:--:|:--:|:--:|:---:|:--:|:--:|:--:|:--:|:---:|:--:|:--:|:--:| |Accuracy|85.0|78.7 |78.9|77.8|76.6|77.4|75.3 |72.5|73.1|76.1|73.2|76.5 |69.6|68.4|67.3| # Environmental Impact Carbon emissions can be estimated using the [Machine Learning Impact calculator](https://mlco2.github.io/impact#compute) presented in [Lacoste et al. (2019)](https://arxiv.org/abs/1910.09700). - **Hardware Type:** 64 Volta GPUs - **Hours used:** More information needed - **Cloud Provider:** More information needed - **Compute Region:** More information needed - **Carbon Emitted:** More information needed # Technical Specifications Details are culled from the [associated paper](https://arxiv.org/pdf/1901.07291.pdf). See the paper for links, citations, and further details. Also see the associated [GitHub Repo](https://github.com/facebookresearch/XLM#ii-cross-lingual-language-model-pretraining-xlm) for further details. ## Model Architecture and Objective xlm-mlm-tlm-xnli15-1024 is a transformer pretrained using a masked language modeling (MLM) objective in combination with a translation language modeling (TLM) objective and then fine-tuned on the English NLI dataset. About the TLM objective, the developers write: > We introduce a new translation language modeling (TLM) objective for improving cross-lingual pretraining. Our TLM objective is an extension of MLM, where instead of considering monolingual text streams, we concatenate parallel sentences as illustrated in Figure 1. We randomly mask words in both the source and target sentences. To predict a word masked in an English sentence, the model can either attend to surrounding English words or to the French translation, encouraging the model to align the English and French representations. ## Compute Infrastructure ### Hardware and Software The developers write: > We implement all our models in PyTorch (Paszke et al., 2017), and train them on 64 Volta GPUs for the language modeling tasks, and 8 GPUs for the MT tasks. We use float16 operations to speed up training and to reduce the memory usage of our models. # Citation **BibTeX:** ```bibtex @article{lample2019cross, title={Cross-lingual language model pretraining}, author={Lample, Guillaume and Conneau, Alexis}, journal={arXiv preprint arXiv:1901.07291}, year={2019} } ``` **APA:** - Lample, G., & Conneau, A. (2019). Cross-lingual language model pretraining. arXiv preprint arXiv:1901.07291. # Model Card Authors This model card was written by the team at Hugging Face. # How to Get Started with the Model This model uses language embeddings to specify the language used at inference. See the [Hugging Face Multilingual Models for Inference docs](https://huggingface.co/docs/transformers/v4.20.1/en/multilingual#xlm-with-language-embeddings) for further details.
pritamdeka/S-Biomed-Roberta-snli-multinli-stsb
97bd79d282037621d2e75b13b3f6a11a1d38e55f
2022-03-09T11:54:11.000Z
[ "pytorch", "roberta", "feature-extraction", "sentence-transformers", "sentence-similarity", "transformers" ]
sentence-similarity
false
pritamdeka
null
pritamdeka/S-Biomed-Roberta-snli-multinli-stsb
586
null
sentence-transformers
2,183
--- pipeline_tag: sentence-similarity tags: - sentence-transformers - feature-extraction - sentence-similarity - transformers --- # S-Biomed-Roberta-snli-multinli-stsb This is a [sentence-transformers](https://www.SBERT.net) model: It maps sentences & paragraphs to a 768 dimensional dense vector space and can be used for tasks like clustering or semantic search. The base model used is [allenai/biomed_roberta_base](https://huggingface.co/allenai/biomed_roberta_base) which has been fine-tuned for sentence similarity. <!--- Describe your model here --> ## Usage (Sentence-Transformers) Using this model becomes easy when you have [sentence-transformers](https://www.SBERT.net) installed: ``` pip install -U sentence-transformers ``` Then you can use the model like this: ```python from sentence_transformers import SentenceTransformer sentences = ["This is an example sentence", "Each sentence is converted"] model = SentenceTransformer('pritamdeka/S-Biomed-Roberta-snli-multinli-stsb') embeddings = model.encode(sentences) print(embeddings) ``` ## Usage (HuggingFace Transformers) Without [sentence-transformers](https://www.SBERT.net), you can use the model like this: First, you pass your input through the transformer model, then you have to apply the right pooling-operation on-top of the contextualized word embeddings. ```python from transformers import AutoTokenizer, AutoModel import torch #Mean Pooling - Take attention mask into account for correct averaging def mean_pooling(model_output, attention_mask): token_embeddings = model_output[0] #First element of model_output contains all token embeddings input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float() return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9) # Sentences we want sentence embeddings for sentences = ['This is an example sentence', 'Each sentence is converted'] # Load model from HuggingFace Hub tokenizer = AutoTokenizer.from_pretrained('pritamdeka/S-Biomed-Roberta-snli-multinli-stsb') model = AutoModel.from_pretrained('pritamdeka/S-Biomed-Roberta-snli-multinli-stsb') # Tokenize sentences encoded_input = tokenizer(sentences, padding=True, truncation=True, return_tensors='pt') # Compute token embeddings with torch.no_grad(): model_output = model(**encoded_input) # Perform pooling. In this case, max pooling. sentence_embeddings = mean_pooling(model_output, encoded_input['attention_mask']) print("Sentence embeddings:") print(sentence_embeddings) ``` ## Evaluation Results <!--- Describe how your model was evaluated --> For an automated evaluation of this model, see the *Sentence Embeddings Benchmark*: [https://seb.sbert.net](https://seb.sbert.net?model_name={MODEL_NAME}) ## Training The model was trained with the parameters: **DataLoader**: `torch.utils.data.dataloader.DataLoader` of length 90 with parameters: ``` {'batch_size': 64, 'sampler': 'torch.utils.data.sampler.RandomSampler', 'batch_sampler': 'torch.utils.data.sampler.BatchSampler'} ``` **Loss**: `sentence_transformers.losses.CosineSimilarityLoss.CosineSimilarityLoss` Parameters of the fit()-Method: ``` { "callback": null, "epochs": 4, "evaluation_steps": 1000, "evaluator": "sentence_transformers.evaluation.EmbeddingSimilarityEvaluator.EmbeddingSimilarityEvaluator", "max_grad_norm": 1, "optimizer_class": "<class 'transformers.optimization.AdamW'>", "optimizer_params": { "lr": 2e-05 }, "scheduler": "WarmupLinear", "steps_per_epoch": null, "warmup_steps": 36, "weight_decay": 0.01 } ``` ## Full Model Architecture ``` SentenceTransformer( (0): Transformer({'max_seq_length': 75, 'do_lower_case': False}) with Transformer model: RobertaModel (1): Pooling({'word_embedding_dimension': 768, 'pooling_mode_cls_token': False, 'pooling_mode_mean_tokens': True, 'pooling_mode_max_tokens': False, 'pooling_mode_mean_sqrt_len_tokens': False}) ) ``` ## Citing & Authors <!--- Describe where people can find more information --> To cite the wonderful work of sentence transformers use the citation given below. ``` @article{reimers2019sentence, title={Sentence-bert: Sentence embeddings using siamese bert-networks}, author={Reimers, Nils and Gurevych, Iryna}, journal={arXiv preprint arXiv:1908.10084}, year={2019} } ```
mrm8488/bert-mini-finetuned-age_news-classification
3ec65518ec27cd9851400bf3df347fda6ba68fc0
2021-05-20T00:26:16.000Z
[ "pytorch", "jax", "bert", "text-classification", "en", "dataset:ag_news", "transformers", "news", "classification", "mini" ]
text-classification
false
mrm8488
null
mrm8488/bert-mini-finetuned-age_news-classification
585
3
transformers
2,184
--- language: en tags: - news - classification - mini datasets: - ag_news widget: - text: "Israel withdraws from Gaza camp Israel withdraws from Khan Younis refugee camp in the Gaza Strip, after a four-day operation that left 11 dead." --- # BERT-Mini fine-tuned on age_news dataset for news classification Test set accuray: 0.93
NlpHUST/gpt-neo-vi-small
b63ce90cdb2e69a5398ccf63baf74285efeeacbb
2021-04-23T07:21:34.000Z
[ "pytorch", "gpt_neo", "text-generation", "transformers" ]
text-generation
false
NlpHUST
null
NlpHUST/gpt-neo-vi-small
584
null
transformers
2,185
--- language: - vi tags: - text generation - pytorch # GPT-Neo-small for vietnamese First GPT for vietnamese ## Model Description GPT-Neo-vi-small is a transformer model designed using EleutherAI's replication of the GPT-3 architecture. ## Training data GPT-Neo-vi-smal was trained on the News datasets, a large scale dataset created by from News Website for the purpose of training this model. ### How to use his example generates a different sequence each time it's run: ```py from transformers import GPTNeoForCausalLM, GPT2Tokenizer model = GPTNeoForCausalLM.from_pretrained("NlpHUST/gpt-neo-vi-small") tokenizer = GPT2Tokenizer.from_pretrained("NlpHUST/gpt-neo-vi-small") prompt = "Ngay sau Tết Nguyên đán Tân Sửu, hiện tượng giá đất tăng tại nhiều địa phương. Thị trường nhộn nhịp, tạo ra những cơn sóng sốt đất khó tin khiến bộ ngành, địa phương đưa cảnh báo." input_ids = tokenizer(prompt, return_tensors="pt").input_ids gen_tokens = model.generate(input_ids, do_sample=True, temperature=1.0, max_length=1024) gen_text = tokenizer.batch_decode(gen_tokens)[0] print(gen_text) ``` ### Contact information For personal communication related to this project, please contact Nha Nguyen Van ([email protected]).
markussagen/xlm-roberta-longformer-base-4096
98bc749a58deebb8811a07a57040a3219277b61f
2022-03-30T09:24:39.000Z
[ "pytorch", "xlm-roberta", "fill-mask", "multilingual", "dataset:wikitext", "transformers", "longformer", "license:apache-2.0", "autotrain_compatible" ]
fill-mask
false
markussagen
null
markussagen/xlm-roberta-longformer-base-4096
583
10
transformers
2,186
--- tags: - longformer language: multilingual license: apache-2.0 datasets: - wikitext --- ## XLM-R Longformer Model / XLM-Long XLM-R Longformer (or XLM-Long for short) is a XLM-R model that has been extended to allow sequence lengths up to 4096 tokens, instead of the regular 512. The model was pre-trained from the XLM-RoBERTa checkpoint using the Longformer [pre-training scheme](https://github.com/allenai/longformer/blob/master/scripts/convert_model_to_long.ipynb) on the English WikiText-103 corpus. The reason for this was to investigate methods for creating efficient Transformers for low-resource languages, such as Swedish, without the need to pre-train them on long-context datasets in each respecitve language. The trained model came as a result of a master thesis project at [Peltarion](https://peltarion.com/) and was fine-tuned on multilingual quesion-answering tasks, with code available [here](https://github.com/MarkusSagen/Master-Thesis-Multilingual-Longformer#xlm-r). Since both XLM-R model and Longformer models are large models, it it recommended to run the models with NVIDIA Apex (16bit precision), large GPU and several gradient accumulation steps. ## How to Use The model can be used as expected to fine-tune on a downstream task. For instance for QA. ```python import torch from transformers import AutoModel, AutoTokenizer MAX_SEQUENCE_LENGTH = 4096 MODEL_NAME_OR_PATH = "markussagen/xlm-roberta-longformer-base-4096" tokenizer = AutoTokenizer.from_pretrained( MODEL_NAME_OR_PATH, max_length=MAX_SEQUENCE_LENGTH, padding="max_length", truncation=True, ) model = AutoModelForQuestionAnswering.from_pretrained( MODEL_NAME_OR_PATH, max_length=MAX_SEQUENCE_LENGTH, ) ``` ## Training Procedure The model have been trained on the WikiText-103 corpus, using a **48GB** GPU with the following training script and parameters. The model was pre-trained for 6000 iterations and took ~5 days. See the full [training script](https://github.com/MarkusSagen/Master-Thesis-Multilingual-Longformer/blob/main/scripts/finetune_qa_models.py) and [Github repo](https://github.com/MarkusSagen/Master-Thesis-Multilingual-Longformer) for more information ```sh wget https://s3.amazonaws.com/research.metamind.io/wikitext/wikitext-103-raw-v1.zip unzip wikitext-103-raw-v1.zip export DATA_DIR=./wikitext-103-raw scripts/run_long_lm.py \ --model_name_or_path xlm-roberta-base \ --model_name xlm-roberta-to-longformer \ --output_dir ./output \ --logging_dir ./logs \ --val_file_path $DATA_DIR/wiki.valid.raw \ --train_file_path $DATA_DIR/wiki.train.raw \ --seed 42 \ --max_pos 4096 \ --adam_epsilon 1e-8 \ --warmup_steps 500 \ --learning_rate 3e-5 \ --weight_decay 0.01 \ --max_steps 6000 \ --evaluate_during_training \ --logging_steps 50 \ --eval_steps 50 \ --save_steps 6000 \ --max_grad_norm 1.0 \ --per_device_eval_batch_size 2 \ --per_device_train_batch_size 1 \ --gradient_accumulation_steps 64 \ --overwrite_output_dir \ --fp16 \ --do_train \ --do_eval ```
tau/splinter-base
d6bc929405a27b7502bbab767f615c89b0e52373
2021-08-17T14:09:19.000Z
[ "pytorch", "splinter", "question-answering", "en", "transformers", "SplinterModel", "license:apache-2.0", "autotrain_compatible" ]
question-answering
false
tau
null
tau/splinter-base
582
1
transformers
2,187
--- language: en tags: - splinter - SplinterModel license: apache-2.0 --- # Splinter base model Splinter-base is the pretrained model discussed in the paper [Few-Shot Question Answering by Pretraining Span Selection](https://aclanthology.org/2021.acl-long.239/) (at ACL 2021). Its original repository can be found [here](https://github.com/oriram/splinter). The model is case-sensitive. Note: This model **doesn't** contain the pretrained weights for the QASS layer (see paper for details), and therefore the QASS layer is randomly initialized upon loading it. For the model **with** those weights, see [tau/splinter-base-qass](https://huggingface.co/tau/splinter-base-qass). ## Model description Splinter is a model that is pretrained in a self-supervised fashion for few-shot question answering. This means it was pretrained on the raw texts only, with no humans labelling them in any way (which is why it can use lots of publicly available data) with an automatic process to generate inputs and labels from those texts. More precisely, it was pretrained with the Recurring Span Selection (RSS) objective, which emulates the span selection process involved in extractive question answering. Given a text, clusters of recurring spans (n-grams that appear more than once in the text) are first identified. For each such cluster, all of its instances but one are replaced with a special `[QUESTION]` token, and the model should select the correct (i.e., unmasked) span for each masked one. The model also defines the Question-Aware Span selection (QASS) layer, which selects spans conditioned on a specific question (in order to perform multiple predictions). ## Intended uses & limitations The prime use for this model is few-shot extractive QA. ## Pretraining The model was pretrained on a v3-8 TPU for 2.4M steps. The training data is based on **Wikipedia** and **BookCorpus**. See the paper for more details. ### BibTeX entry and citation info ```bibtex @inproceedings{ram-etal-2021-shot, title = "Few-Shot Question Answering by Pretraining Span Selection", author = "Ram, Ori and Kirstain, Yuval and Berant, Jonathan and Globerson, Amir and Levy, Omer", booktitle = "Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International Joint Conference on Natural Language Processing (Volume 1: Long Papers)", month = aug, year = "2021", address = "Online", publisher = "Association for Computational Linguistics", url = "https://aclanthology.org/2021.acl-long.239", doi = "10.18653/v1/2021.acl-long.239", pages = "3066--3079", } ```
antoiloui/belgpt2
af72b5d53d2be0e47fac2df7367d7205cd73e8dd
2021-05-21T13:21:55.000Z
[ "pytorch", "tf", "jax", "gpt2", "text-generation", "fr", "transformers", "license:mit" ]
text-generation
false
antoiloui
null
antoiloui/belgpt2
581
null
transformers
2,188
--- language: - fr license: - mit widget: - text: "Hier, Elon Musk a" - text: "Pourquoi a-t-il" - text: "Tout à coup, elle" --- # Belgian GPT-2 🇧🇪 **A GPT-2 model pre-trained on a very large and heterogeneous French corpus (~60Gb).** ## Usage You can use BelGPT-2 with [🤗 transformers](https://github.com/huggingface/transformers): ```python import torch from transformers import GPT2Tokenizer, GPT2LMHeadModel # Load pretrained model and tokenizer model = GPT2LMHeadModel.from_pretrained("antoiloui/belgpt2") tokenizer = GPT2Tokenizer.from_pretrained("antoiloui/belgpt2") # Generate a sample of text model.eval() output = model.generate( bos_token_id=random.randint(1,50000), do_sample=True, top_k=50, max_length=100, top_p=0.95, num_return_sequences=1 ) # Decode it decoded_output = [] for sample in output: decoded_output.append(tokenizer.decode(sample, skip_special_tokens=True)) print(decoded_output) ``` ## Data Below is the list of all French copora used to pre-trained the model: | Dataset | `$corpus_name` | Raw size | Cleaned size | | :------| :--- | :---: | :---: | | CommonCrawl | `common_crawl` | 200.2 GB | 40.4 GB | | NewsCrawl | `news_crawl` | 10.4 GB | 9.8 GB | | Wikipedia | `wiki` | 19.4 GB | 4.1 GB | | Wikisource | `wikisource` | 4.6 GB | 2.3 GB | | Project Gutenberg | `gutenberg` | 1.3 GB | 1.1 GB | | EuroParl | `europarl` | 289.9 MB | 278.7 MB | | NewsCommentary | `news_commentary` | 61.4 MB | 58.1 MB | | **Total** | | **236.3 GB** | **57.9 GB** | ## Documentation Detailed documentation on the pre-trained model, its implementation, and the data can be found [here](https://github.com/antoiloui/belgpt2/blob/master/docs/index.md). ## Citation For attribution in academic contexts, please cite this work as: ``` @misc{louis2020belgpt2, author = {Louis, Antoine}, title = {{BelGPT-2: a GPT-2 model pre-trained on French corpora.}}, year = {2020}, howpublished = {\url{https://github.com/antoiloui/belgpt2}}, } ```
marrrcin/PolBERTa-base-polish-cased-v1
e930aab409927552cc43911b3011db3deced16bf
2021-05-20T17:45:35.000Z
[ "pytorch", "jax", "roberta", "fill-mask", "transformers", "autotrain_compatible" ]
fill-mask
false
marrrcin
null
marrrcin/PolBERTa-base-polish-cased-v1
581
null
transformers
2,189
Entry not found
openai/imagegpt-small
0e11e1401d0dfe6e45e4c0b2d92808b239cc9501
2022-06-30T06:46:51.000Z
[ "pytorch", "imagegpt", "dataset:imagenet-21k", "transformers", "vision", "license:apache-2.0" ]
null
false
openai
null
openai/imagegpt-small
581
null
transformers
2,190
--- license: apache-2.0 tags: - vision datasets: - imagenet-21k --- # ImageGPT (small-sized model) ImageGPT (iGPT) model pre-trained on ImageNet ILSVRC 2012 (14 million images, 21,843 classes) at resolution 32x32. It was introduced in the paper [Generative Pretraining from Pixels](https://cdn.openai.com/papers/Generative_Pretraining_from_Pixels_V2.pdf) by Chen et al. and first released in [this repository](https://github.com/openai/image-gpt). See also the official [blog post](https://openai.com/blog/image-gpt/). Disclaimer: The team releasing ImageGPT did not write a model card for this model so this model card has been written by the Hugging Face team. ## Model description The ImageGPT (iGPT) is a transformer decoder model (GPT-like) pretrained on a large collection of images in a self-supervised fashion, namely ImageNet-21k, at a resolution of 32x32 pixels. The goal for the model is simply to predict the next pixel value, given the previous ones. By pre-training the model, it learns an inner representation of images that can then be used to: - extract features useful for downstream tasks: one can either use ImageGPT to produce fixed image features, in order to train a linear model (like a sklearn logistic regression model or SVM). This is also referred to as "linear probing". - perform (un)conditional image generation. ## Intended uses & limitations You can use the raw model for either feature extractor or (un) conditional image generation. See the [model hub](https://huggingface.co/models?search=openai/imagegpt) to all ImageGPT variants. ### How to use Here is how to use this model in PyTorch to perform unconditional image generation: ```python from transformers import ImageGPTFeatureExtractor, ImageGPTForCausalImageModeling import torch import matplotlib.pyplot as plt import numpy as np feature_extractor = ImageGPTFeatureExtractor.from_pretrained('openai/imagegpt-small') model = ImageGPTForCausalImageModeling.from_pretrained('openai/imagegpt-small') device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model.to(device) # unconditional generation of 8 images batch_size = 8 context = torch.full((batch_size, 1), model.config.vocab_size - 1) #initialize with SOS token context = torch.tensor(context).to(device) output = model.generate(pixel_values=context, max_length=model.config.n_positions + 1, temperature=1.0, do_sample=True, top_k=40) clusters = feature_extractor.clusters n_px = feature_extractor.size samples = output[:,1:].cpu().detach().numpy() samples_img = [np.reshape(np.rint(127.5 * (clusters[s] + 1.0)), [n_px, n_px, 3]).astype(np.uint8) for s in samples] # convert color cluster tokens back to pixels f, axes = plt.subplots(1, batch_size, dpi=300) for img, ax in zip(samples_img, axes): ax.axis('off') ax.imshow(img) ``` ## Training data The ImageGPT model was pretrained on [ImageNet-21k](http://www.image-net.org/), a dataset consisting of 14 million images and 21k classes. ## Training procedure ### Preprocessing Images are first resized/rescaled to the same resolution (32x32) and normalized across the RGB channels. Next, color-clustering is performed. This means that every pixel is turned into one of 512 possible cluster values. This way, one ends up with a sequence of 32x32 = 1024 pixel values, rather than 32x32x3 = 3072, which is prohibitively large for Transformer-based models. ### Pretraining Training details can be found in section 3.4 of v2 of the paper. ## Evaluation results For evaluation results on several image classification benchmarks, we refer to the original paper. ### BibTeX entry and citation info ```bibtex @InProceedings{pmlr-v119-chen20s, title = {Generative Pretraining From Pixels}, author = {Chen, Mark and Radford, Alec and Child, Rewon and Wu, Jeffrey and Jun, Heewoo and Luan, David and Sutskever, Ilya}, booktitle = {Proceedings of the 37th International Conference on Machine Learning}, pages = {1691--1703}, year = {2020}, editor = {III, Hal Daumé and Singh, Aarti}, volume = {119}, series = {Proceedings of Machine Learning Research}, month = {13--18 Jul}, publisher = {PMLR}, pdf = {http://proceedings.mlr.press/v119/chen20s/chen20s.pdf}, url = {https://proceedings.mlr.press/v119/chen20s.html } ``` ```bibtex @inproceedings{deng2009imagenet, title={Imagenet: A large-scale hierarchical image database}, author={Deng, Jia and Dong, Wei and Socher, Richard and Li, Li-Jia and Li, Kai and Fei-Fei, Li}, booktitle={2009 IEEE conference on computer vision and pattern recognition}, pages={248--255}, year={2009}, organization={Ieee} } ```
patrickvonplaten/wav2vec2-base-100h-with-lm
0612413f4d1532f2e50c039b2f014722ea59db4e
2022-05-23T23:09:37.000Z
[ "pytorch", "wav2vec2", "automatic-speech-recognition", "transformers" ]
automatic-speech-recognition
false
patrickvonplaten
null
patrickvonplaten/wav2vec2-base-100h-with-lm
581
5
transformers
2,191
Hello
uer/gpt2-chinese-ancient
e3306e958d8d6b6b161276f83ac6214bcd693273
2022-07-15T08:26:24.000Z
[ "pytorch", "tf", "jax", "gpt2", "text-generation", "zh", "transformers" ]
text-generation
false
uer
null
uer/gpt2-chinese-ancient
581
1
transformers
2,192
--- language: zh widget: - text: "[CLS]当是时" --- # Chinese Ancient GPT2 Model ## Model description The model is used to generate ancient Chinese. You can download the model either from the [GPT2-Chinese Github page](https://github.com/Morizeyao/GPT2-Chinese), or via HuggingFace from the link [gpt2-chinese-ancient](https://huggingface.co/uer/gpt2-chinese-ancient) ## How to use You can use the model directly with a pipeline for text generation: ```python >>> from transformers import BertTokenizer, GPT2LMHeadModel, TextGenerationPipeline >>> tokenizer = BertTokenizer.from_pretrained("uer/gpt2-chinese-ancient") >>> model = GPT2LMHeadModel.from_pretrained("uer/gpt2-chinese-ancient") >>> text_generator = TextGenerationPipeline(model, tokenizer) >>> text_generator("当是时", max_length=100, do_sample=True) [{'generated_text': '[CLS]当是时 所 议 者 不 为 无 据 ， 况 亦 在 之 列 乎 ？ 然 则 今 日 之 事 ， 所 当 思 者 在 何 ？ 欲 求 国 是 于 天 下 ， 莫 在 于 得 人 。 臣 以 为 求 人 之 法 ， 不 在 多 用 官 一 途 。 诚 使 得 才 者 众 ， 人 才 者 优 ， 则 治 所 当 得 ， 而 不 事 于 官 者 ， 人 才 乃 其 常 也 。 所 当 讲 者'}] ``` ## Training data Training data contains 3,000,000 ancient Chinese which are collected by [daizhigev20](https://github.com/garychowcmu/daizhigev20). Since part of ancient corpus has no punctuation, we used the [ancient Chinese punctuation system](https://seg.shenshen.wiki) developed by [BNU ICIP lab](http://icip.bnu.edu.cn/).　 ## Training procedure The model is pre-trained by [UER-py](https://github.com/dbiir/UER-py/) on [Tencent Cloud](https://cloud.tencent.com/). We pre-train 500,000 steps with a sequence length of 320. We use extended vocabulary to handle out-of-vocabulary words. The Chinese character that occurs greater than or equal to 100 in ancient Chinese corpus is added to the vocabulary. ``` python3 preprocess.py --corpus_path corpora/ancient_chinese.txt \ --vocab_path models/google_zh_vocab.txt \ --dataset_path ancient_chinese_dataset.pt --processes_num 16 \ --seq_length 320 --data_processor lm ``` ``` python3 pretrain.py --dataset_path ancient_chinese_dataset.pt \ --vocab_path models/google_zh_vocab.txt \ --config_path models/bert_base_config.json \ --output_model_path models/ancient_chinese_gpt2_model.bin \ --world_size 8 --gpu_ranks 0 1 2 3 4 5 6 7 \ --total_steps 500000 --save_checkpoint_steps 100000 --report_steps 10000 \ --learning_rate 5e-4 --batch_size 32 ``` Finally, we convert the pre-trained model into Huggingface's format: ``` python3 scripts/convert_gpt2_from_uer_to_huggingface.py --input_model_path ancient_chinese_gpt2_model.bin-500000 \ --output_model_path pytorch_model.bin \ --layers_num 12 ``` ### BibTeX entry and citation info ``` @article{radford2019language, title={Language Models are Unsupervised Multitask Learners}, author={Radford, Alec and Wu, Jeff and Child, Rewon and Luan, David and Amodei, Dario and Sutskever, Ilya}, year={2019} } @article{zhao2019uer, title={UER: An Open-Source Toolkit for Pre-training Models}, author={Zhao, Zhe and Chen, Hui and Zhang, Jinbin and Zhao, Xin and Liu, Tao and Lu, Wei and Chen, Xi and Deng, Haotang and Ju, Qi and Du, Xiaoyong}, journal={EMNLP-IJCNLP 2019}, pages={241}, year={2019} } ```
albert-xlarge-v2
0ba5a4b12dff18dbb93712e5ab5ea252c09728d8
2021-01-13T15:34:57.000Z
[ "pytorch", "tf", "albert", "fill-mask", "en", "dataset:bookcorpus", "dataset:wikipedia", "arxiv:1909.11942", "transformers", "license:apache-2.0", "autotrain_compatible" ]
fill-mask
false
null
null
albert-xlarge-v2
580
1
transformers
2,193
--- language: en license: apache-2.0 datasets: - bookcorpus - wikipedia --- # ALBERT XLarge v2 Pretrained model on English language using a masked language modeling (MLM) objective. It was introduced in [this paper](https://arxiv.org/abs/1909.11942) and first released in [this repository](https://github.com/google-research/albert). This model, as all ALBERT models, is uncased: it does not make a difference between english and English. Disclaimer: The team releasing ALBERT did not write a model card for this model so this model card has been written by the Hugging Face team. ## Model description ALBERT is a transformers model pretrained on a large corpus of English data in a self-supervised fashion. This means it was pretrained on the raw texts only, with no humans labelling them in any way (which is why it can use lots of publicly available data) with an automatic process to generate inputs and labels from those texts. More precisely, it was pretrained with two objectives: - Masked language modeling (MLM): taking a sentence, the model randomly masks 15% of the words in the input then run the entire masked sentence through the model and has to predict the masked words. This is different from traditional recurrent neural networks (RNNs) that usually see the words one after the other, or from autoregressive models like GPT which internally mask the future tokens. It allows the model to learn a bidirectional representation of the sentence. - Sentence Ordering Prediction (SOP): ALBERT uses a pretraining loss based on predicting the ordering of two consecutive segments of text. This way, the model learns an inner representation of the English language that can then be used to extract features useful for downstream tasks: if you have a dataset of labeled sentences for instance, you can train a standard classifier using the features produced by the ALBERT model as inputs. ALBERT is particular in that it shares its layers across its Transformer. Therefore, all layers have the same weights. Using repeating layers results in a small memory footprint, however, the computational cost remains similar to a BERT-like architecture with the same number of hidden layers as it has to iterate through the same number of (repeating) layers. This is the second version of the xlarge model. Version 2 is different from version 1 due to different dropout rates, additional training data, and longer training. It has better results in nearly all downstream tasks. This model has the following configuration: - 24 repeating layers - 128 embedding dimension - 2048 hidden dimension - 16 attention heads - 58M parameters ## Intended uses & limitations You can use the raw model for either masked language modeling or next sentence prediction, but it's mostly intended to be fine-tuned on a downstream task. See the [model hub](https://huggingface.co/models?filter=albert) to look for fine-tuned versions on a task that interests you. Note that this model is primarily aimed at being fine-tuned on tasks that use the whole sentence (potentially masked) to make decisions, such as sequence classification, token classification or question answering. For tasks such as text generation you should look at model like GPT2. ### How to use You can use this model directly with a pipeline for masked language modeling: ```python >>> from transformers import pipeline >>> unmasker = pipeline('fill-mask', model='albert-xlarge-v2') >>> unmasker("Hello I'm a [MASK] model.") [ { "sequence":"[CLS] hello i'm a modeling model.[SEP]", "score":0.05816134437918663, "token":12807, "token_str":"▁modeling" }, { "sequence":"[CLS] hello i'm a modelling model.[SEP]", "score":0.03748830780386925, "token":23089, "token_str":"▁modelling" }, { "sequence":"[CLS] hello i'm a model model.[SEP]", "score":0.033725276589393616, "token":1061, "token_str":"▁model" }, { "sequence":"[CLS] hello i'm a runway model.[SEP]", "score":0.017313428223133087, "token":8014, "token_str":"▁runway" }, { "sequence":"[CLS] hello i'm a lingerie model.[SEP]", "score":0.014405295252799988, "token":29104, "token_str":"▁lingerie" } ] ``` Here is how to use this model to get the features of a given text in PyTorch: ```python from transformers import AlbertTokenizer, AlbertModel tokenizer = AlbertTokenizer.from_pretrained('albert-xlarge-v2') model = AlbertModel.from_pretrained("albert-xlarge-v2") text = "Replace me by any text you'd like." encoded_input = tokenizer(text, return_tensors='pt') output = model(**encoded_input) ``` and in TensorFlow: ```python from transformers import AlbertTokenizer, TFAlbertModel tokenizer = AlbertTokenizer.from_pretrained('albert-xlarge-v2') model = TFAlbertModel.from_pretrained("albert-xlarge-v2") text = "Replace me by any text you'd like." encoded_input = tokenizer(text, return_tensors='tf') output = model(encoded_input) ``` ### Limitations and bias Even if the training data used for this model could be characterized as fairly neutral, this model can have biased predictions: ```python >>> from transformers import pipeline >>> unmasker = pipeline('fill-mask', model='albert-xlarge-v2') >>> unmasker("The man worked as a [MASK].") [ { "sequence":"[CLS] the man worked as a chauffeur.[SEP]", "score":0.029577180743217468, "token":28744, "token_str":"▁chauffeur" }, { "sequence":"[CLS] the man worked as a janitor.[SEP]", "score":0.028865724802017212, "token":29477, "token_str":"▁janitor" }, { "sequence":"[CLS] the man worked as a shoemaker.[SEP]", "score":0.02581118606030941, "token":29024, "token_str":"▁shoemaker" }, { "sequence":"[CLS] the man worked as a blacksmith.[SEP]", "score":0.01849772222340107, "token":21238, "token_str":"▁blacksmith" }, { "sequence":"[CLS] the man worked as a lawyer.[SEP]", "score":0.01820771023631096, "token":3672, "token_str":"▁lawyer" } ] >>> unmasker("The woman worked as a [MASK].") [ { "sequence":"[CLS] the woman worked as a receptionist.[SEP]", "score":0.04604868218302727, "token":25331, "token_str":"▁receptionist" }, { "sequence":"[CLS] the woman worked as a janitor.[SEP]", "score":0.028220869600772858, "token":29477, "token_str":"▁janitor" }, { "sequence":"[CLS] the woman worked as a paramedic.[SEP]", "score":0.0261906236410141, "token":23386, "token_str":"▁paramedic" }, { "sequence":"[CLS] the woman worked as a chauffeur.[SEP]", "score":0.024797942489385605, "token":28744, "token_str":"▁chauffeur" }, { "sequence":"[CLS] the woman worked as a waitress.[SEP]", "score":0.024124596267938614, "token":13678, "token_str":"▁waitress" } ] ``` This bias will also affect all fine-tuned versions of this model. ## Training data The ALBERT model was pretrained on [BookCorpus](https://yknzhu.wixsite.com/mbweb), a dataset consisting of 11,038 unpublished books and [English Wikipedia](https://en.wikipedia.org/wiki/English_Wikipedia) (excluding lists, tables and headers). ## Training procedure ### Preprocessing The texts are lowercased and tokenized using SentencePiece and a vocabulary size of 30,000. The inputs of the model are then of the form: ``` [CLS] Sentence A [SEP] Sentence B [SEP] ``` ### Training The ALBERT procedure follows the BERT setup. The details of the masking procedure for each sentence are the following: - 15% of the tokens are masked. - In 80% of the cases, the masked tokens are replaced by `[MASK]`. - In 10% of the cases, the masked tokens are replaced by a random token (different) from the one they replace. - In the 10% remaining cases, the masked tokens are left as is. ## Evaluation results When fine-tuned on downstream tasks, the ALBERT models achieve the following results: | | Average | SQuAD1.1 | SQuAD2.0 | MNLI | SST-2 | RACE | |----------------|----------|----------|----------|----------|----------|----------| |V2 | |ALBERT-base |82.3 |90.2/83.2 |82.1/79.3 |84.6 |92.9 |66.8 | |ALBERT-large |85.7 |91.8/85.2 |84.9/81.8 |86.5 |94.9 |75.2 | |ALBERT-xlarge |87.9 |92.9/86.4 |87.9/84.1 |87.9 |95.4 |80.7 | |ALBERT-xxlarge |90.9 |94.6/89.1 |89.8/86.9 |90.6 |96.8 |86.8 | |V1 | |ALBERT-base |80.1 |89.3/82.3 | 80.0/77.1|81.6 |90.3 | 64.0 | |ALBERT-large |82.4 |90.6/83.9 | 82.3/79.4|83.5 |91.7 | 68.5 | |ALBERT-xlarge |85.5 |92.5/86.1 | 86.1/83.1|86.4 |92.4 | 74.8 | |ALBERT-xxlarge |91.0 |94.8/89.3 | 90.2/87.4|90.8 |96.9 | 86.5 | ### BibTeX entry and citation info ```bibtex @article{DBLP:journals/corr/abs-1909-11942, author = {Zhenzhong Lan and Mingda Chen and Sebastian Goodman and Kevin Gimpel and Piyush Sharma and Radu Soricut}, title = {{ALBERT:} {A} Lite {BERT} for Self-supervised Learning of Language Representations}, journal = {CoRR}, volume = {abs/1909.11942}, year = {2019}, url = {http://arxiv.org/abs/1909.11942}, archivePrefix = {arXiv}, eprint = {1909.11942}, timestamp = {Fri, 27 Sep 2019 13:04:21 +0200}, biburl = {https://dblp.org/rec/journals/corr/abs-1909-11942.bib}, bibsource = {dblp computer science bibliography, https://dblp.org} } ```
valhalla/bart-large-sst2
9f63197f937e01b890f892902e7afc809b9c0b06
2022-04-05T11:50:37.000Z
[ "pytorch", "bart", "text-classification", "transformers" ]
text-classification
false
valhalla
null
valhalla/bart-large-sst2
580
null
transformers
2,194
Entry not found
obrizum/all-MiniLM-L6-v2
3825f80b81a4edec9da5f16a020659f4f827ae18
2022-05-09T06:48:12.000Z
[ "pytorch", "bert", "feature-extraction", "en", "arxiv:1904.06472", "arxiv:2102.07033", "arxiv:2104.08727", "arxiv:1704.05179", "arxiv:1810.09305", "sentence-transformers", "sentence-similarity", "license:apache-2.0" ]
feature-extraction
false
obrizum
null
obrizum/all-MiniLM-L6-v2
580
null
sentence-transformers
2,195
--- pipeline_tag: feature-extraction tags: - sentence-transformers - feature-extraction - sentence-similarity language: en license: apache-2.0 --- # all-MiniLM-L6-v2 This is a [sentence-transformers](https://www.SBERT.net) model: It maps sentences & paragraphs to a 384 dimensional dense vector space and can be used for tasks like clustering or semantic search. ## Usage (Sentence-Transformers) Using this model becomes easy when you have [sentence-transformers](https://www.SBERT.net) installed: ``` pip install -U sentence-transformers ``` Then you can use the model like this: ```python from sentence_transformers import SentenceTransformer sentences = ["This is an example sentence", "Each sentence is converted"] model = SentenceTransformer('obrizum/all-MiniLM-L6-v2') embeddings = model.encode(sentences) print(embeddings) ``` ## Usage (HuggingFace Transformers) Without [sentence-transformers](https://www.SBERT.net), you can use the model like this: First, you pass your input through the transformer model, then you have to apply the right pooling-operation on-top of the contextualized word embeddings. ```python from transformers import AutoTokenizer, AutoModel import torch import torch.nn.functional as F #Mean Pooling - Take attention mask into account for correct averaging def mean_pooling(model_output, attention_mask): token_embeddings = model_output[0] #First element of model_output contains all token embeddings input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float() return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9) # Sentences we want sentence embeddings for sentences = ['This is an example sentence', 'Each sentence is converted'] # Load model from HuggingFace Hub tokenizer = AutoTokenizer.from_pretrained('obrizum/all-MiniLM-L6-v2') model = AutoModel.from_pretrained('obrizum/all-MiniLM-L6-v2') # Tokenize sentences encoded_input = tokenizer(sentences, padding=True, truncation=True, return_tensors='pt') # Compute token embeddings with torch.no_grad(): model_output = model(**encoded_input) # Perform pooling sentence_embeddings = mean_pooling(model_output, encoded_input['attention_mask']) # Normalize embeddings sentence_embeddings = F.normalize(sentence_embeddings, p=2, dim=1) print("Sentence embeddings:") print(sentence_embeddings) ``` ## Evaluation Results For an automated evaluation of this model, see the *Sentence Embeddings Benchmark*: [https://seb.sbert.net](https://seb.sbert.net?model_name=sentence-transformers/all-MiniLM-L6-v2) ------ ## Background The project aims to train sentence embedding models on very large sentence level datasets using a self-supervised contrastive learning objective. We used the pretrained [`nreimers/MiniLM-L6-H384-uncased`](https://huggingface.co/nreimers/MiniLM-L6-H384-uncased) model and fine-tuned in on a 1B sentence pairs dataset. We use a contrastive learning objective: given a sentence from the pair, the model should predict which out of a set of randomly sampled other sentences, was actually paired with it in our dataset. We developped this model during the [Community week using JAX/Flax for NLP & CV](https://discuss.huggingface.co/t/open-to-the-community-community-week-using-jax-flax-for-nlp-cv/7104), organized by Hugging Face. We developped this model as part of the project: [Train the Best Sentence Embedding Model Ever with 1B Training Pairs](https://discuss.huggingface.co/t/train-the-best-sentence-embedding-model-ever-with-1b-training-pairs/7354). We benefited from efficient hardware infrastructure to run the project: 7 TPUs v3-8, as well as intervention from Googles Flax, JAX, and Cloud team member about efficient deep learning frameworks. ## Intended uses Our model is intented to be used as a sentence and short paragraph encoder. Given an input text, it ouptuts a vector which captures the semantic information. The sentence vector may be used for information retrieval, clustering or sentence similarity tasks. By default, input text longer than 256 word pieces is truncated. ## Training procedure ### Pre-training We use the pretrained [`nreimers/MiniLM-L6-H384-uncased`](https://huggingface.co/nreimers/MiniLM-L6-H384-uncased) model. Please refer to the model card for more detailed information about the pre-training procedure. ### Fine-tuning We fine-tune the model using a contrastive objective. Formally, we compute the cosine similarity from each possible sentence pairs from the batch. We then apply the cross entropy loss by comparing with true pairs. #### Hyper parameters We trained ou model on a TPU v3-8. We train the model during 100k steps using a batch size of 1024 (128 per TPU core). We use a learning rate warm up of 500. The sequence length was limited to 128 tokens. We used the AdamW optimizer with a 2e-5 learning rate. The full training script is accessible in this current repository: `train_script.py`. #### Training data We use the concatenation from multiple datasets to fine-tune our model. The total number of sentence pairs is above 1 billion sentences. We sampled each dataset given a weighted probability which configuration is detailed in the `data_config.json` file. | Dataset | Paper | Number of training tuples | |--------------------------------------------------------|:----------------------------------------:|:--------------------------:| | [Reddit comments (2015-2018)](https://github.com/PolyAI-LDN/conversational-datasets/tree/master/reddit) | [paper](https://arxiv.org/abs/1904.06472) | 726,484,430 | | [S2ORC](https://github.com/allenai/s2orc) Citation pairs (Abstracts) | [paper](https://aclanthology.org/2020.acl-main.447/) | 116,288,806 | | [WikiAnswers](https://github.com/afader/oqa#wikianswers-corpus) Duplicate question pairs | [paper](https://doi.org/10.1145/2623330.2623677) | 77,427,422 | | [PAQ](https://github.com/facebookresearch/PAQ) (Question, Answer) pairs | [paper](https://arxiv.org/abs/2102.07033) | 64,371,441 | | [S2ORC](https://github.com/allenai/s2orc) Citation pairs (Titles) | [paper](https://aclanthology.org/2020.acl-main.447/) | 52,603,982 | | [S2ORC](https://github.com/allenai/s2orc) (Title, Abstract) | [paper](https://aclanthology.org/2020.acl-main.447/) | 41,769,185 | | [Stack Exchange](https://huggingface.co/datasets/flax-sentence-embeddings/stackexchange_xml) (Title, Body) pairs | - | 25,316,456 | | [Stack Exchange](https://huggingface.co/datasets/flax-sentence-embeddings/stackexchange_xml) (Title+Body, Answer) pairs | - | 21,396,559 | | [Stack Exchange](https://huggingface.co/datasets/flax-sentence-embeddings/stackexchange_xml) (Title, Answer) pairs | - | 21,396,559 | | [MS MARCO](https://microsoft.github.io/msmarco/) triplets | [paper](https://doi.org/10.1145/3404835.3462804) | 9,144,553 | | [GOOAQ: Open Question Answering with Diverse Answer Types](https://github.com/allenai/gooaq) | [paper](https://arxiv.org/pdf/2104.08727.pdf) | 3,012,496 | | [Yahoo Answers](https://www.kaggle.com/soumikrakshit/yahoo-answers-dataset) (Title, Answer) | [paper](https://proceedings.neurips.cc/paper/2015/hash/250cf8b51c773f3f8dc8b4be867a9a02-Abstract.html) | 1,198,260 | | [Code Search](https://huggingface.co/datasets/code_search_net) | - | 1,151,414 | | [COCO](https://cocodataset.org/#home) Image captions | [paper](https://link.springer.com/chapter/10.1007%2F978-3-319-10602-1_48) | 828,395| | [SPECTER](https://github.com/allenai/specter) citation triplets | [paper](https://doi.org/10.18653/v1/2020.acl-main.207) | 684,100 | | [Yahoo Answers](https://www.kaggle.com/soumikrakshit/yahoo-answers-dataset) (Question, Answer) | [paper](https://proceedings.neurips.cc/paper/2015/hash/250cf8b51c773f3f8dc8b4be867a9a02-Abstract.html) | 681,164 | | [Yahoo Answers](https://www.kaggle.com/soumikrakshit/yahoo-answers-dataset) (Title, Question) | [paper](https://proceedings.neurips.cc/paper/2015/hash/250cf8b51c773f3f8dc8b4be867a9a02-Abstract.html) | 659,896 | | [SearchQA](https://huggingface.co/datasets/search_qa) | [paper](https://arxiv.org/abs/1704.05179) | 582,261 | | [Eli5](https://huggingface.co/datasets/eli5) | [paper](https://doi.org/10.18653/v1/p19-1346) | 325,475 | | [Flickr 30k](https://shannon.cs.illinois.edu/DenotationGraph/) | [paper](https://transacl.org/ojs/index.php/tacl/article/view/229/33) | 317,695 | | [Stack Exchange](https://huggingface.co/datasets/flax-sentence-embeddings/stackexchange_xml) Duplicate questions (titles) | | 304,525 | | AllNLI ([SNLI](https://nlp.stanford.edu/projects/snli/) and [MultiNLI](https://cims.nyu.edu/~sbowman/multinli/) | [paper SNLI](https://doi.org/10.18653/v1/d15-1075), [paper MultiNLI](https://doi.org/10.18653/v1/n18-1101) | 277,230 | | [Stack Exchange](https://huggingface.co/datasets/flax-sentence-embeddings/stackexchange_xml) Duplicate questions (bodies) | | 250,519 | | [Stack Exchange](https://huggingface.co/datasets/flax-sentence-embeddings/stackexchange_xml) Duplicate questions (titles+bodies) | | 250,460 | | [Sentence Compression](https://github.com/google-research-datasets/sentence-compression) | [paper](https://www.aclweb.org/anthology/D13-1155/) | 180,000 | | [Wikihow](https://github.com/pvl/wikihow_pairs_dataset) | [paper](https://arxiv.org/abs/1810.09305) | 128,542 | | [Altlex](https://github.com/chridey/altlex/) | [paper](https://aclanthology.org/P16-1135.pdf) | 112,696 | | [Quora Question Triplets](https://quoradata.quora.com/First-Quora-Dataset-Release-Question-Pairs) | - | 103,663 | | [Simple Wikipedia](https://cs.pomona.edu/~dkauchak/simplification/) | [paper](https://www.aclweb.org/anthology/P11-2117/) | 102,225 | | [Natural Questions (NQ)](https://ai.google.com/research/NaturalQuestions) | [paper](https://transacl.org/ojs/index.php/tacl/article/view/1455) | 100,231 | | [SQuAD2.0](https://rajpurkar.github.io/SQuAD-explorer/) | [paper](https://aclanthology.org/P18-2124.pdf) | 87,599 | | [TriviaQA](https://huggingface.co/datasets/trivia_qa) | - | 73,346 | | **Total** | | **1,170,060,424** |
salti/bert-base-multilingual-cased-finetuned-squad
0368c75d052222a1188f1fd5c5b97f4064e58567
2021-05-19T01:26:36.000Z
[ "pytorch", "tf", "jax", "bert", "question-answering", "multilingual", "dataset:squad", "dataset:arcd", "dataset:xquad", "transformers", "autotrain_compatible" ]
question-answering
false
salti
null
salti/bert-base-multilingual-cased-finetuned-squad
579
5
transformers
2,196
--- language: - multilingual datasets: - squad - arcd - xquad --- # Multilingual BERT fine-tuned on SQuADv1.1 [**WandB run link**](https://wandb.ai/salti/mBERT_QA/runs/wkqzhrp2) **GPU**: Tesla P100-PCIE-16GB ## Training Arguments ```python max_seq_length = 512 doc_stride = 256 max_answer_length = 64 bacth_size = 16 gradient_accumulation_steps = 2 learning_rate = 5e-5 weight_decay = 3e-7 num_train_epochs = 3 warmup_ratio = 0.1 fp16 = True fp16_opt_level = "O1" seed = 0 ``` ## Results | EM | F1 | | :----: | :----: | | 81.731 | 89.009 | ## Zero-shot performance ### on ARCD | EM | F1 | | :----: | :----: | | 20.655 | 48.051 | ### on XQuAD | Language | EM | F1 | | :--------: | :----: | :----: | | Arabic | 42.185 | 57.803 | | English | 73.529 | 85.01 | | German | 55.882 | 72.555 | | Greek | 45.21 | 62.207 | | Spanish | 58.067 | 76.406 | | Hindi | 40.588 | 55.29 | | Russian | 55.126 | 71.617 | | Thai | 26.891 | 39.965 | | Turkish | 34.874 | 51.138 | | Vietnamese | 47.983 | 68.125 | | Chinese | 47.395 | 58.928 |
prithivida/formal_to_informal_styletransfer
45b495b2b2992d9e43bb96b69dd6c7fd86282db2
2021-06-21T08:08:37.000Z
[ "pytorch", "t5", "text2text-generation", "transformers", "autotrain_compatible" ]
text2text-generation
false
prithivida
null
prithivida/formal_to_informal_styletransfer
578
3
transformers
2,197
## This model belongs to the Styleformer project [Please refer to github page](https://github.com/PrithivirajDamodaran/Styleformer)
UBC-NLP/MARBERTv2
fe88db9db8ccdb0c4e1627495f405c44a5f89066
2022-03-30T21:52:31.000Z
[ "pytorch", "tf", "bert", "fill-mask", "ar", "transformers", "Arabic BERT", "MSA", "Twitter", "Masked Langauge Model", "autotrain_compatible" ]
fill-mask
false
UBC-NLP
null
UBC-NLP/MARBERTv2
577
4
transformers
2,198
--- language: - ar tags: - Arabic BERT - MSA - Twitter - Masked Langauge Model widget: - text: "اللغة العربية هي لغة [MASK]." --- <img src="https://raw.githubusercontent.com/UBC-NLP/marbert/main/ARBERT_MARBERT.jpg" alt="drawing" width="30%" height="30%" align="right"/> **MARBERTv2** is one of three models described in our **ACL 2021 paper** **["ARBERT & MARBERT: Deep Bidirectional Transformers for Arabic"](https://aclanthology.org/2021.acl-long.551.pdf)**. We find that results with ARBERT and MARBERT on QA are not competitive, a clear discrepancy from what we have observed thus far on other tasksWe hypothesize this is because the two models are pre-trained with a sequence length of only 128, which does not allow them to sufficiently capture both a question and its likely answer within the same sequence window during the pre-training. To rectify this, we further pre-train the stronger model, MARBERT, on the same MSA data as ARBERT in addition to AraNews dataset but with a bigger sequence length of 512 tokens for 40 epochs. We call this further pre-trained model **MARBERTv2**, noting it has **29B tokens**. MARBERTv2 acquires best performance on all but one test set, where XLM-RLarge marginally outperforms us (only in F1). For more information, please visit our own GitHub [repo](https://github.com/UBC-NLP/marbert). # BibTex If you use our models (ARBERT, MARBERT, or MARBERTv2) for your scientific publication, or if you find the resources in this repository useful, please cite our paper as follows (to be updated): ```bibtex @inproceedings{abdul-mageed-etal-2021-arbert, title = "{ARBERT} {\&} {MARBERT}: Deep Bidirectional Transformers for {A}rabic", author = "Abdul-Mageed, Muhammad and Elmadany, AbdelRahim and Nagoudi, El Moatez Billah", booktitle = "Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International Joint Conference on Natural Language Processing (Volume 1: Long Papers)", month = aug, year = "2021", address = "Online", publisher = "Association for Computational Linguistics", url = "https://aclanthology.org/2021.acl-long.551", doi = "10.18653/v1/2021.acl-long.551", pages = "7088--7105", abstract = "Pre-trained language models (LMs) are currently integral to many natural language processing systems. Although multilingual LMs were also introduced to serve many languages, these have limitations such as being costly at inference time and the size and diversity of non-English data involved in their pre-training. We remedy these issues for a collection of diverse Arabic varieties by introducing two powerful deep bidirectional transformer-based models, ARBERT and MARBERT. To evaluate our models, we also introduce ARLUE, a new benchmark for multi-dialectal Arabic language understanding evaluation. ARLUE is built using 42 datasets targeting six different task clusters, allowing us to offer a series of standardized experiments under rich conditions. When fine-tuned on ARLUE, our models collectively achieve new state-of-the-art results across the majority of tasks (37 out of 48 classification tasks, on the 42 datasets). Our best model acquires the highest ARLUE score (77.40) across all six task clusters, outperforming all other models including XLM-R Large ( 3.4x larger size). Our models are publicly available at https://github.com/UBC-NLP/marbert and ARLUE will be released through the same repository.", } ``` ## Acknowledgments We gratefully acknowledge support from the Natural Sciences and Engineering Research Council of Canada, the Social Sciences and Humanities Research Council of Canada, Canadian Foundation for Innovation, [ComputeCanada](www.computecanada.ca) and [UBC ARC-Sockeye](https://doi.org/10.14288/SOCKEYE). We also thank the [Google TensorFlow Research Cloud (TFRC)](https://www.tensorflow.org/tfrc) program for providing us with free TPU access.
blinoff/roberta-base-russian-v0
ece3e93280de7fe6f2f95bbbfc1182a87e78e1c5
2021-05-20T14:29:09.000Z
[ "pytorch", "jax", "roberta", "fill-mask", "ru", "transformers", "autotrain_compatible" ]
fill-mask
false
blinoff
null
blinoff/roberta-base-russian-v0
575
1
transformers
2,199
--- language: ru widget: - text: "Мозг — это машина <mask>, которая пытается снизить ошибку в прогнозе." --- # RoBERTa-like language model trained on part of part of TAIGA corpus ## Training Details - about 60k steps ![]() ## Example pipeline ```python from transformers import pipeline from transformers import RobertaTokenizerFast tokenizer = RobertaTokenizerFast.from_pretrained('blinoff/roberta-base-russian-v0', max_len=512) fill_mask = pipeline( "fill-mask", model="blinoff/roberta-base-russian-v0", tokenizer=tokenizer ) fill_mask("Мозг — это машина <mask>, которая пытается снизить ошибку в прогнозе.") # { # 'sequence': '<s>Мозг — это машина города, которая пытается снизить ошибку в прогнозе.</s>', # 'score': 0.012859329581260681, # 'token': 2144, # 'token_str': 'ĠгоÑĢода' # }, # { # 'sequence': '<s>Мозг — это машина человека, которая пытается снизить ошибку в прогнозе.</s>', # 'score': 0.01185101643204689, # 'token': 1470, # 'token_str': 'ĠÑĩеловека' # }, # { # 'sequence': '<s>Мозг — это машина дома, которая пытается снизить ошибку в прогнозе.</s>', # 'score': 0.009940559044480324, # 'token': 1411, # 'token_str': 'Ġдома' # }, # { # 'sequence': '<s>Мозг — это машина женщина, которая пытается снизить ошибку в прогнозе.</s>', # 'score': 0.007794599514454603, # 'token': 2707, # 'token_str': 'ĠженÑīина' # }, # { # 'sequence': '<s>Мозг — это машина женщины, которая пытается снизить ошибку в прогнозе.</s>', # 'score': 0.007725382689386606, # 'token': 3546, # 'token_str': 'ĠженÑīинÑĭ' # } ```