





"""simple docstring"""




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

import os
from pathlib import Path





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

						# BLUE scores as follows:
						# "pair": [fairseq, transformers]
						_UpperCamelCase			:					Optional[Any]     =    {
						    '''wmt19-de-en-6-6-base''': [0, 38.37],
						    '''wmt19-de-en-6-6-big''': [0, 39.90],
						}
						_UpperCamelCase			:					Union[str, Any]     =    F"""{src_lang}-{tgt_lang}"""

						_UpperCamelCase			:					Tuple     =    F"""
---

language:
- {src_lang}
- {tgt_lang}
thumbnail:
tags:
- translation
- wmt19
- allenai
license: apache-2.0
datasets:
- wmt19
metrics:
- bleu
---

# FSMT

## Model description

This is a ported version of fairseq-based [wmt19 transformer](https://github.com/jungokasai/deep-shallow/) for {src_lang}-{tgt_lang}.

For more details, please, see [Deep Encoder, Shallow Decoder: Reevaluating the Speed-Quality Tradeoff in Machine Translation](https://arxiv.org/abs/2006.10369).

2 models are available:

* [wmt19-de-en-6-6-big](https://huggingface.co/allenai/wmt19-de-en-6-6-big)
* [wmt19-de-en-6-6-base](https://huggingface.co/allenai/wmt19-de-en-6-6-base)


## Intended uses & limitations

#### How to use

```python
from transformers import FSMTForConditionalGeneration, FSMTTokenizer
mname = \"allenai/{model_name}\"
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


## Training data

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

## Eval results

Here are the BLEU scores:

model   |  transformers
-------|---------
{model_name}  |  {scores[model_name][1]}

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=5
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 allenai/{model_name} $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
```

## 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

```
@misc{{kasai2020deep,
    title={{Deep Encoder, Shallow Decoder: Reevaluating the Speed-Quality Tradeoff in Machine Translation}},
    author={{Jungo Kasai and Nikolaos Pappas and Hao Peng and James Cross and Noah A. Smith}},
    year={{2020}},
    eprint={{2006.10369}},
    archivePrefix={{arXiv}},
    primaryClass={{cs.CL}}
}}
```

"""
						model_card_dir.mkdir(parents=_lowercase       ,						exist_ok=_lowercase   )
						_UpperCamelCase			:					List[str]     =    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
UpperCamelCase_           =Path(__file__).resolve().parent.parent.parent
UpperCamelCase_           =repo_dir / """model_cards"""

for model_name in ["wmt19-de-en-6-6-base", "wmt19-de-en-6-6-big"]:
						UpperCamelCase_           =model_cards_dir / """allenai""" / model_name
						write_model_card(model_card_dir, src_lang="""de""", tgt_lang="""en""", model_name=model_name)










"""simple docstring"""




import unittest

import numpy as np

from transformers import ElectraConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


if is_flax_available():
						from transformers.models.electra.modeling_flax_electra import (
						    FlaxElectraForCausalLM,
						    FlaxElectraForMaskedLM,
						    FlaxElectraForMultipleChoice,
						    FlaxElectraForPreTraining,
						    FlaxElectraForQuestionAnswering,
						    FlaxElectraForSequenceClassification,
						    FlaxElectraForTokenClassification,
						    FlaxElectraModel,
						)




class  _a						(      unittest.TestCase				):






				def __init__( self		:    str, lowerCAmelCase__		:    Tuple, lowerCAmelCase__		:    List[str]=1_3, lowerCAmelCase__		:    Optional[int]=7, lowerCAmelCase__		:    Optional[Any]=True, lowerCAmelCase__		:    Optional[int]=True, lowerCAmelCase__		:    Any=True, lowerCAmelCase__		:    str=True, lowerCAmelCase__		:    Any=9_9, lowerCAmelCase__		:    Union[str, Any]=2_4, lowerCAmelCase__		:    Optional[Any]=3_2, lowerCAmelCase__		:    Tuple=5, lowerCAmelCase__		:    int=4, lowerCAmelCase__		:    List[Any]=3_7, lowerCAmelCase__		:    Dict="gelu", lowerCAmelCase__		:    Any=0.1, lowerCAmelCase__		:    Any=0.1, lowerCAmelCase__		:    str=5_1_2, lowerCAmelCase__		:    Tuple=1_6, lowerCAmelCase__		:    int=2, lowerCAmelCase__		:    int=0.02, lowerCAmelCase__		:    Optional[int]=4, )	->      Union[str, Any]:




										'''simple docstring'''



										_UpperCamelCase			:					Dict     =    parent
										_UpperCamelCase			:					Tuple     =    batch_size
										_UpperCamelCase			:					str     =    seq_length
										_UpperCamelCase			:					Any     =    is_training
										_UpperCamelCase			:					Union[str, Any]     =    use_attention_mask
										_UpperCamelCase			:					List[Any]     =    use_token_type_ids
										_UpperCamelCase			:					str     =    use_labels
										_UpperCamelCase			:					Union[str, Any]     =    vocab_size
										_UpperCamelCase			:					int     =    hidden_size
										_UpperCamelCase			:					Optional[int]     =    embedding_size
										_UpperCamelCase			:					int     =    num_hidden_layers
										_UpperCamelCase			:					int     =    num_attention_heads
										_UpperCamelCase			:					Tuple     =    intermediate_size
										_UpperCamelCase			:					Optional[int]     =    hidden_act
										_UpperCamelCase			:					Any     =    hidden_dropout_prob
										_UpperCamelCase			:					Union[str, Any]     =    attention_probs_dropout_prob
										_UpperCamelCase			:					Any     =    max_position_embeddings
										_UpperCamelCase			:					List[str]     =    type_vocab_size
										_UpperCamelCase			:					Union[str, Any]     =    type_sequence_label_size
										_UpperCamelCase			:					str     =    initializer_range
										_UpperCamelCase			:					Union[str, Any]     =    num_choices






				def 				snake_case	( self		:    Optional[Any]							)	->      Union[str, Any]:




										'''simple docstring'''



										_UpperCamelCase			:					Optional[Any]     =    ids_tensor([self.batch_size, self.seq_length], self.vocab_size							)

										_UpperCamelCase			:					Dict     =    None
										if self.use_attention_mask:
																_UpperCamelCase			:					Union[str, Any]     =    random_attention_mask([self.batch_size, self.seq_length]							)

										_UpperCamelCase			:					Optional[Any]     =    None
										if self.use_token_type_ids:
																_UpperCamelCase			:					Union[str, Any]     =    ids_tensor([self.batch_size, self.seq_length], self.type_vocab_size							)

										_UpperCamelCase			:					Optional[Any]     =    ElectraConfig(
										    vocab_size=self.vocab_size, hidden_size=self.hidden_size, embedding_size=self.embedding_size, num_hidden_layers=self.num_hidden_layers, num_attention_heads=self.num_attention_heads, intermediate_size=self.intermediate_size, hidden_act=self.hidden_act, hidden_dropout_prob=self.hidden_dropout_prob, attention_probs_dropout_prob=self.attention_probs_dropout_prob, max_position_embeddings=self.max_position_embeddings, type_vocab_size=self.type_vocab_size, initializer_range=self.initializer_range, )

										return config, input_ids, token_type_ids, attention_mask






				def 				snake_case	( self		:    Any							)	->      Optional[int]:




										'''simple docstring'''



										_UpperCamelCase			:					Dict     =    self.prepare_config_and_inputs()
										_UpperCamelCase   ,							_UpperCamelCase   ,							_UpperCamelCase   ,							_UpperCamelCase			:					Tuple     =    config_and_inputs
										_UpperCamelCase			:					List[Any]     =    {'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': attention_mask}
										return config, inputs_dict




@require_flax
class  _a						(      _lowerCAmelCase	,				unittest.TestCase				):
				UpperCamelCase								=    True

				UpperCamelCase								=    (
				    (
				        FlaxElectraModel,
				        FlaxElectraForCausalLM,
				        FlaxElectraForMaskedLM,
				        FlaxElectraForPreTraining,
				        FlaxElectraForTokenClassification,
				        FlaxElectraForQuestionAnswering,
				        FlaxElectraForMultipleChoice,
				        FlaxElectraForSequenceClassification,
				    )
				    if is_flax_available()
				    else ()
				)






				def 				snake_case	( self		:    Union[str, Any]							)	->      Optional[Any]:




										'''simple docstring'''



										_UpperCamelCase			:					List[Any]     =    FlaxElectraModelTester(self							)






				@slow
				def 				snake_case	( self		:    Optional[Any]							)	->      str:




										'''simple docstring'''



										for model_class_name in self.all_model_classes:
																if model_class_name == FlaxElectraForMaskedLM:
																						_UpperCamelCase			:					int     =    model_class_name.from_pretrained('''google/electra-small-generator'''							)
																else:
																						_UpperCamelCase			:					Any     =    model_class_name.from_pretrained('''google/electra-small-discriminator'''							)
																_UpperCamelCase			:					List[str]     =    model(np.ones((1, 1)							)							)
																self.assertIsNotNone(lowerCAmelCase__							)



