






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

import os
from pathlib import Path






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

   # BLUE scores as follows:
   # "pair": [fairseq, transformers]
   UpperCamelCase_									=     {
       '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'],
   }
   UpperCamelCase_									=     f"""{src_lang}-{tgt_lang}"""

   UpperCamelCase_									=     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(__lowercase    ,      exist_ok=__lowercase)
   UpperCamelCase_									=     os.path.join(__lowercase    ,      'README.md')
   print(f"""Generating {path}""")
   with open(__lowercase    ,      'w'    ,      encoding='utf-8') as f:
      f.write(__lowercase)


# make sure we are under the root of the project
snake_case__      :	int       	=      Path(__file__).resolve().parent.parent.parent
snake_case__      :	Tuple       	=      repo_dir / """model_cards"""

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













from collections import OrderedDict
from typing import TYPE_CHECKING, Any, Mapping, Optional

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import logging


if TYPE_CHECKING:
 from ...processing_utils import ProcessorMixin
 from ...utils import TensorType


snake_case__      :	Tuple       	=      logging.get_logger(__name__)

snake_case__      :	str       	=      {
    """microsoft/layoutlmv3-base""": """https://huggingface.co/microsoft/layoutlmv3-base/resolve/main/config.json""",
}


class 						_a       (  UpperCAmelCase__    ):






  """simple docstring"""





  A_						=   """layoutlmv3"""




  def __init__(     self		,		_UpperCAmelCase=50265		,		_UpperCAmelCase=768		,		_UpperCAmelCase=12		,		_UpperCAmelCase=12		,		_UpperCAmelCase=3072		,		_UpperCAmelCase="gelu"		,		_UpperCAmelCase=0.1		,		_UpperCAmelCase=0.1		,		_UpperCAmelCase=512		,		_UpperCAmelCase=2		,		_UpperCAmelCase=0.0_2		,		_UpperCAmelCase=1e-5		,		_UpperCAmelCase=1		,		_UpperCAmelCase=0		,		_UpperCAmelCase=2		,		_UpperCAmelCase=1024		,		_UpperCAmelCase=128		,		_UpperCAmelCase=128		,		_UpperCAmelCase=True		,		_UpperCAmelCase=32		,		_UpperCAmelCase=128		,		_UpperCAmelCase=64		,		_UpperCAmelCase=256		,		_UpperCAmelCase=True		,		_UpperCAmelCase=True		,		_UpperCAmelCase=True		,		_UpperCAmelCase=224		,		_UpperCAmelCase=3		,		_UpperCAmelCase=16		,		_UpperCAmelCase=None		,		**_UpperCAmelCase		,		)			-> Tuple:
     super().__init__(
         vocab_size=_UpperCAmelCase		,		hidden_size=_UpperCAmelCase		,		num_hidden_layers=_UpperCAmelCase		,		num_attention_heads=_UpperCAmelCase		,		intermediate_size=_UpperCAmelCase		,		hidden_act=_UpperCAmelCase		,		hidden_dropout_prob=_UpperCAmelCase		,		attention_probs_dropout_prob=_UpperCAmelCase		,		max_position_embeddings=_UpperCAmelCase		,		type_vocab_size=_UpperCAmelCase		,		initializer_range=_UpperCAmelCase		,		layer_norm_eps=_UpperCAmelCase		,		pad_token_id=_UpperCAmelCase		,		bos_token_id=_UpperCAmelCase		,		eos_token_id=_UpperCAmelCase		,		**_UpperCAmelCase		,		)
     UpperCamelCase_									=     max_ad_position_embeddings
     UpperCamelCase_									=     coordinate_size
     UpperCamelCase_									=     shape_size
     UpperCamelCase_									=     has_relative_attention_bias
     UpperCamelCase_									=     rel_pos_bins
     UpperCamelCase_									=     max_rel_pos
     UpperCamelCase_									=     has_spatial_attention_bias
     UpperCamelCase_									=     rel_ad_pos_bins
     UpperCamelCase_									=     max_rel_ad_pos
     UpperCamelCase_									=     text_embed
     UpperCamelCase_									=     visual_embed
     UpperCamelCase_									=     input_size
     UpperCamelCase_									=     num_channels
     UpperCamelCase_									=     patch_size
     UpperCamelCase_									=     classifier_dropout




class 						_a       (  UpperCAmelCase__    ):






  """simple docstring"""





  A_						=   version.parse("""1.12"""    )




  @property
  def    _UpperCAmelCase     (     self )			-> Mapping[str, Mapping[int, str]]:
     # The order of inputs is different for question answering and sequence classification
     if self.task in ["question-answering", "sequence-classification"]:
        return OrderedDict(
            [
                ('input_ids', {0: 'batch', 1: 'sequence'}),
                ('attention_mask', {0: 'batch', 1: 'sequence'}),
                ('bbox', {0: 'batch', 1: 'sequence'}),
                ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}),
            ] )
     else:
        return OrderedDict(
            [
                ('input_ids', {0: 'batch', 1: 'sequence'}),
                ('bbox', {0: 'batch', 1: 'sequence'}),
                ('attention_mask', {0: 'batch', 1: 'sequence'}),
                ('pixel_values', {0: 'batch', 1: 'num_channels'}),
            ] )




  @property
  def    _UpperCAmelCase     (     self )			-> float:
     return 1e-5




  @property
  def    _UpperCAmelCase     (     self )			-> int:
     return 12




  def    _UpperCAmelCase     (     self		,		_UpperCAmelCase		,		_UpperCAmelCase = -1		,		_UpperCAmelCase = -1		,		_UpperCAmelCase = False		,		_UpperCAmelCase = None		,		_UpperCAmelCase = 3		,		_UpperCAmelCase = 40		,		_UpperCAmelCase = 40		,		)			-> Mapping[str, Any]:
     setattr(processor.image_processor		,		'apply_ocr'		,		_UpperCAmelCase )

     # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
     UpperCamelCase_									=     compute_effective_axis_dimension(
         _UpperCAmelCase		,		fixed_dimension=OnnxConfig.default_fixed_batch		,		num_token_to_add=0 )
     # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
     UpperCamelCase_									=     processor.tokenizer.num_special_tokens_to_add(_UpperCAmelCase )
     UpperCamelCase_									=     compute_effective_axis_dimension(
         _UpperCAmelCase		,		fixed_dimension=OnnxConfig.default_fixed_sequence		,		num_token_to_add=_UpperCAmelCase )
     # Generate dummy inputs according to compute batch and sequence
     UpperCamelCase_									=     [[' '.join([processor.tokenizer.unk_token] ) * seq_length]] * batch_size

     # Generate dummy bounding boxes
     UpperCamelCase_									=     [[[48, 84, 73, 128]]] * batch_size

     # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
     # batch_size = compute_effective_axis_dimension(batch_size, fixed_dimension=OnnxConfig.default_fixed_batch)
     UpperCamelCase_									=     self._generate_dummy_images(_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase )

     UpperCamelCase_									=     dict(
         processor(
             _UpperCAmelCase		,		text=_UpperCAmelCase		,		boxes=_UpperCAmelCase		,		return_tensors=_UpperCAmelCase		,		) )

     return inputs





