



'''simple docstring'''





# Usage:
# ./gen-card-facebook-wmt19.py

import os
from pathlib import Path
def        _SCREAMING_SNAKE_CASE  (	UpperCamelCase							,   UpperCamelCase							,   UpperCamelCase      ):



    """simple docstring"""





    lowerCAmelCase__			:  Dict											= {
        """en""": """Machine learning is great, isn't it?""",
        """ru""": """Машинное обучение - это здорово, не так ли?""",
        """de""": """Maschinelles Lernen ist großartig, oder?""",
    }

    # BLUE scores as follows:
    # "pair": [fairseq, transformers]
    lowerCAmelCase__			:  Optional[Any]											= {
        """ru-en""": ["""[41.3](http://matrix.statmt.org/matrix/output/1907?run_id=6937)""", """39.20"""],
        """en-ru""": ["""[36.4](http://matrix.statmt.org/matrix/output/1914?run_id=6724)""", """33.47"""],
        """en-de""": ["""[43.1](http://matrix.statmt.org/matrix/output/1909?run_id=6862)""", """42.83"""],
        """de-en""": ["""[42.3](http://matrix.statmt.org/matrix/output/1902?run_id=6750)""", """41.35"""],
    }
    lowerCAmelCase__			:  Any											= f"""{src_lang}-{tgt_lang}"""

    lowerCAmelCase__			:  str											= f"""
---
language: 
- {src_lang}
- {tgt_lang}
thumbnail:
tags:
- translation
- wmt19
- facebook
license: apache-2.0
datasets:
- wmt19
metrics:
- bleu
---

# FSMT

## Model description

This is a ported version of [fairseq wmt19 transformer](https://github.com/pytorch/fairseq/blob/master/examples/wmt19/README.md) for {src_lang}-{tgt_lang}.

For more details, please see, [Facebook FAIR's WMT19 News Translation Task Submission](https://arxiv.org/abs/1907.06616).

The abbreviation FSMT stands for FairSeqMachineTranslation

All four models are available:

* [wmt19-en-ru](https://huggingface.co/facebook/wmt19-en-ru)
* [wmt19-ru-en](https://huggingface.co/facebook/wmt19-ru-en)
* [wmt19-en-de](https://huggingface.co/facebook/wmt19-en-de)
* [wmt19-de-en](https://huggingface.co/facebook/wmt19-de-en)

## Intended uses & limitations

#### How to use

```python
from transformers import FSMTForConditionalGeneration, FSMTTokenizer
mname = \"facebook/wmt19-{src_lang}-{tgt_lang}\"
tokenizer = FSMTTokenizer.from_pretrained(mname)
model = FSMTForConditionalGeneration.from_pretrained(mname)

input = \"{texts[src_lang]}\"
input_ids = tokenizer.encode(input, return_tensors=\"pt\")
outputs = model.generate(input_ids)
decoded = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(decoded) # {texts[tgt_lang]}

```

#### Limitations and bias

- The original (and this ported model) doesn't seem to handle well inputs with repeated sub-phrases, [content gets truncated](https://discuss.huggingface.co/t/issues-with-translating-inputs-containing-repeated-phrases/981)

## Training data

Pretrained weights were left identical to the original model released by fairseq. For more details, please, see the [paper](https://arxiv.org/abs/1907.06616).

## Eval results

pair   | fairseq | transformers
-------|---------|----------
{pair}  | {scores[pair][0]} | {scores[pair][1]}

The score is slightly below the score reported by `fairseq`, since `transformers`` currently doesn't support:
- model ensemble, therefore the best performing checkpoint was ported (``model4.pt``).
- re-ranking

The score was calculated using this code:

```bash
git clone https://github.com/huggingface/transformers
cd transformers
export PAIR={pair}
export DATA_DIR=data/$PAIR
export SAVE_DIR=data/$PAIR
export BS=8
export NUM_BEAMS=15
mkdir -p $DATA_DIR
sacrebleu -t wmt19 -l $PAIR --echo src > $DATA_DIR/val.source
sacrebleu -t wmt19 -l $PAIR --echo ref > $DATA_DIR/val.target
echo $PAIR
PYTHONPATH=\"src:examples/seq2seq\" python examples/seq2seq/run_eval.py facebook/wmt19-$PAIR $DATA_DIR/val.source $SAVE_DIR/test_translations.txt --reference_path $DATA_DIR/val.target --score_path $SAVE_DIR/test_bleu.json --bs $BS --task translation --num_beams $NUM_BEAMS
```
note: fairseq reports using a beam of 50, so you should get a slightly higher score if re-run with `--num_beams 50`.

## Data Sources

- [training, etc.](http://www.statmt.org/wmt19/)
- [test set](http://matrix.statmt.org/test_sets/newstest2019.tgz?1556572561)


### BibTeX entry and citation info

```bibtex
@inproceedings{{...,
  year={{2020}},
  title={{Facebook FAIR's WMT19 News Translation Task Submission}},
  author={{Ng, Nathan and Yee, Kyra and Baevski, Alexei and Ott, Myle and Auli, Michael and Edunov, Sergey}},
  booktitle={{Proc. of WMT}},
}}
```


## TODO

- port model ensemble (fairseq uses 4 model checkpoints)

"""
    os.makedirs(UpperCamelCase							,   exist_ok=UpperCamelCase      )
    lowerCAmelCase__			:  List[Any]											= os.path.join(UpperCamelCase							,   """README.md"""      )
    print(f"""Generating {path}"""      )
    with open(UpperCamelCase							,   """w"""							,   encoding="""utf-8"""      ) as f:
        f.write(UpperCamelCase      )


# make sure we are under the root of the project
_lowerCAmelCase										=     Path(__file__).resolve().parent.parent.parent
_lowerCAmelCase										=     repo_dir / '''model_cards'''

for model_name in ["wmt19-ru-en", "wmt19-en-ru", "wmt19-en-de", "wmt19-de-en"]:
 _lowerCAmelCase						,      _lowerCAmelCase						,      _lowerCAmelCase										=     model_name.split('''-''')
 _lowerCAmelCase										=     model_cards_dir / '''facebook''' / model_name
 write_model_card(model_card_dir, src_lang=src_lang, tgt_lang=tgt_lang)







'''simple docstring'''





import json
import os
import shutil
import tempfile
from unittest import TestCase

from transformers import BartTokenizer, BartTokenizerFast, DPRQuestionEncoderTokenizer, DPRQuestionEncoderTokenizerFast
from transformers.models.bart.configuration_bart import BartConfig
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES as DPR_VOCAB_FILES_NAMES
from transformers.models.dpr.configuration_dpr import DPRConfig
from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES as BART_VOCAB_FILES_NAMES
from transformers.testing_utils import require_faiss, require_tokenizers, require_torch, slow
from transformers.utils import is_datasets_available, is_faiss_available, is_torch_available


if is_torch_available() and is_datasets_available() and is_faiss_available():
 from transformers.models.rag.configuration_rag import RagConfig
 from transformers.models.rag.tokenization_rag import RagTokenizer






@require_faiss
@require_torch
class 	lowerCAmelCase_(    SCREAMING_SNAKE_CASE_					):
  '''simple docstring'''




  def 							UpperCAmelCase_     (   self				)   ->		Dict:
      lowerCAmelCase__			:  str											= tempfile.mkdtemp()
      lowerCAmelCase__			:  List[Any]											= 8

      # DPR tok
      lowerCAmelCase__			:  int											= [
          """[UNK]""",
          """[CLS]""",
          """[SEP]""",
          """[PAD]""",
          """[MASK]""",
          """want""",
          """##want""",
          """##ed""",
          """wa""",
          """un""",
          """runn""",
          """##ing""",
          """,""",
          """low""",
          """lowest""",
      ]
      lowerCAmelCase__			:  List[Any]											= os.path.join(self.tmpdirname  ,"""dpr_tokenizer"""				)
      os.makedirs(__UpperCAmelCase  ,exist_ok=__UpperCAmelCase				)
      lowerCAmelCase__			:  Dict											= os.path.join(__UpperCAmelCase  ,DPR_VOCAB_FILES_NAMES["""vocab_file"""]				)
      with open(self.vocab_file  ,"""w"""  ,encoding="""utf-8"""				) as vocab_writer:
          vocab_writer.write("""""".join([x + """\n""" for x in vocab_tokens]				)				)

      # BART tok
      lowerCAmelCase__			:  str											= [
          """l""",
          """o""",
          """w""",
          """e""",
          """r""",
          """s""",
          """t""",
          """i""",
          """d""",
          """n""",
          """\u0120""",
          """\u0120l""",
          """\u0120n""",
          """\u0120lo""",
          """\u0120low""",
          """er""",
          """\u0120lowest""",
          """\u0120newer""",
          """\u0120wider""",
          """<unk>""",
      ]
      lowerCAmelCase__			:  List[Any]											= dict(zip(__UpperCAmelCase  ,range(len(__UpperCAmelCase				)				)				)				)
      lowerCAmelCase__			:  Optional[Any]											= ["""#version: 0.2""", """\u0120 l""", """\u0120l o""", """\u0120lo w""", """e r""", """"""]
      lowerCAmelCase__			:  Any											= {"""unk_token""": """<unk>"""}

      lowerCAmelCase__			:  str											= os.path.join(self.tmpdirname  ,"""bart_tokenizer"""				)
      os.makedirs(__UpperCAmelCase  ,exist_ok=__UpperCAmelCase				)
      lowerCAmelCase__			:  Any											= os.path.join(__UpperCAmelCase  ,BART_VOCAB_FILES_NAMES["""vocab_file"""]				)
      lowerCAmelCase__			:  Dict											= os.path.join(__UpperCAmelCase  ,BART_VOCAB_FILES_NAMES["""merges_file"""]				)
      with open(self.vocab_file  ,"""w"""  ,encoding="""utf-8"""				) as fp:
          fp.write(json.dumps(__UpperCAmelCase				) + """\n"""				)
      with open(self.merges_file  ,"""w"""  ,encoding="""utf-8"""				) as fp:
          fp.write("""\n""".join(__UpperCAmelCase				)				)




  def 							UpperCAmelCase_     (   self				)   ->		DPRQuestionEncoderTokenizer:
      return DPRQuestionEncoderTokenizer.from_pretrained(os.path.join(self.tmpdirname  ,"""dpr_tokenizer"""				)				)




  def 							UpperCAmelCase_     (   self				)   ->		BartTokenizer:
      return BartTokenizer.from_pretrained(os.path.join(self.tmpdirname  ,"""bart_tokenizer"""				)				)




  def 							UpperCAmelCase_     (   self				)   ->		Any:
      shutil.rmtree(self.tmpdirname				)




  @require_tokenizers
  def 							UpperCAmelCase_     (   self				)   ->		int:
      lowerCAmelCase__			:  Any											= os.path.join(self.tmpdirname  ,"""rag_tokenizer"""				)
      lowerCAmelCase__			:  Any											= RagConfig(question_encoder=DPRConfig().to_dict()  ,generator=BartConfig().to_dict()				)
      lowerCAmelCase__			:  str											= RagTokenizer(question_encoder=self.get_dpr_tokenizer()  ,generator=self.get_bart_tokenizer()				)
      rag_config.save_pretrained(__UpperCAmelCase				)
      rag_tokenizer.save_pretrained(__UpperCAmelCase				)
      lowerCAmelCase__			:  Any											= RagTokenizer.from_pretrained(__UpperCAmelCase  ,config=__UpperCAmelCase				)
      self.assertIsInstance(new_rag_tokenizer.question_encoder  ,__UpperCAmelCase				)
      self.assertEqual(new_rag_tokenizer.question_encoder.get_vocab()  ,rag_tokenizer.question_encoder.get_vocab()				)
      self.assertIsInstance(new_rag_tokenizer.generator  ,__UpperCAmelCase				)
      self.assertEqual(new_rag_tokenizer.generator.get_vocab()  ,rag_tokenizer.generator.get_vocab()				)




  @slow
  def 							UpperCAmelCase_     (   self				)   ->		Union[str, Any]:
      lowerCAmelCase__			:  List[str]											= RagTokenizer.from_pretrained("""facebook/rag-token-nq"""				)
      lowerCAmelCase__			:  Optional[Any]											= [
          """who got the first nobel prize in physics""",
          """when is the next deadpool movie being released""",
          """which mode is used for short wave broadcast service""",
          """who is the owner of reading football club""",
          """when is the next scandal episode coming out""",
          """when is the last time the philadelphia won the superbowl""",
          """what is the most current adobe flash player version""",
          """how many episodes are there in dragon ball z""",
          """what is the first step in the evolution of the eye""",
          """where is gall bladder situated in human body""",
          """what is the main mineral in lithium batteries""",
          """who is the president of usa right now""",
          """where do the greasers live in the outsiders""",
          """panda is a national animal of which country""",
          """what is the name of manchester united stadium""",
      ]
      lowerCAmelCase__			:  Dict											= tokenizer(__UpperCAmelCase				)
      self.assertIsNotNone(__UpperCAmelCase				)






  @slow
  def 							UpperCAmelCase_     (   self				)   ->		Union[str, Any]:
      lowerCAmelCase__			:  str											= RagTokenizer.from_pretrained("""facebook/rag-sequence-nq"""				)
      lowerCAmelCase__			:  str											= [
          """who got the first nobel prize in physics""",
          """when is the next deadpool movie being released""",
          """which mode is used for short wave broadcast service""",
          """who is the owner of reading football club""",
          """when is the next scandal episode coming out""",
          """when is the last time the philadelphia won the superbowl""",
          """what is the most current adobe flash player version""",
          """how many episodes are there in dragon ball z""",
          """what is the first step in the evolution of the eye""",
          """where is gall bladder situated in human body""",
          """what is the main mineral in lithium batteries""",
          """who is the president of usa right now""",
          """where do the greasers live in the outsiders""",
          """panda is a national animal of which country""",
          """what is the name of manchester united stadium""",
      ]
      lowerCAmelCase__			:  Tuple											= tokenizer(__UpperCAmelCase				)
      self.assertIsNotNone(__UpperCAmelCase				)


