



"""simple docstring"""






import json
import os
import shutil
import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

from huggingface_hub import HfFolder, delete_repo
from requests.exceptions import HTTPError

from transformers import AutoConfig, BertConfig, GPTaConfig
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test


sys.path.append(str(Path(__file__).parent.parent / "utils"))

from test_module.custom_configuration import CustomConfig  # noqa E402


_lowercase			:			Union[str, Any]										=						{
    "return_dict": False,
    "output_hidden_states": True,
    "output_attentions": True,
    "torchscript": True,
    "torch_dtype": "float16",
    "use_bfloat16": True,
    "tf_legacy_loss": True,
    "pruned_heads": {"a": 1},
    "tie_word_embeddings": False,
    "is_decoder": True,
    "cross_attention_hidden_size": 1_2_8,
    "add_cross_attention": True,
    "tie_encoder_decoder": True,
    "max_length": 5_0,
    "min_length": 3,
    "do_sample": True,
    "early_stopping": True,
    "num_beams": 3,
    "num_beam_groups": 3,
    "diversity_penalty": 0.5,
    "temperature": 2.0,
    "top_k": 1_0,
    "top_p": 0.7,
    "typical_p": 0.2,
    "repetition_penalty": 0.8,
    "length_penalty": 0.8,
    "no_repeat_ngram_size": 5,
    "encoder_no_repeat_ngram_size": 5,
    "bad_words_ids": [1, 2, 3],
    "num_return_sequences": 3,
    "chunk_size_feed_forward": 5,
    "output_scores": True,
    "return_dict_in_generate": True,
    "forced_bos_token_id": 2,
    "forced_eos_token_id": 3,
    "remove_invalid_values": True,
    "architectures": ["BertModel"],
    "finetuning_task": "translation",
    "id2label": {0: "label"},
    "label2id": {"label": "0"},
    "tokenizer_class": "BertTokenizerFast",
    "prefix": "prefix",
    "bos_token_id": 6,
    "pad_token_id": 7,
    "eos_token_id": 8,
    "sep_token_id": 9,
    "decoder_start_token_id": 1_0,
    "exponential_decay_length_penalty": (5, 1.01),
    "suppress_tokens": [0, 1],
    "begin_suppress_tokens": 2,
    "task_specific_params": {"translation": "some_params"},
    "problem_type": "regression",
}

@is_staging_test
class 	__SCREAMING_SNAKE_CASE     (				unittest.TestCase       ):


					'''simple docstring'''





					@classmethod
					def 		snake_case	(	cls							:  Dict					)-> Optional[Any]:
								lowerCamelCase__		:		str		     =TOKEN
								HfFolder.save_token(lowerCamelCase					)



					@classmethod
					def 		snake_case	(	cls							:  str					)-> List[str]:
								try:
											delete_repo(token=cls._token,  repo_id='''test-config'''					)
								except HTTPError:
											pass

								try:
											delete_repo(token=cls._token,  repo_id='''valid_org/test-config-org'''					)
								except HTTPError:
											pass

								try:
											delete_repo(token=cls._token,  repo_id='''test-dynamic-config'''					)
								except HTTPError:
											pass



					def 		snake_case	(	self							:  Dict					)-> int:
								lowerCamelCase__		:		Union[str, Any]		     =BertConfig(
								    vocab_size=99,  hidden_size=32,  num_hidden_layers=5,  num_attention_heads=4,  intermediate_size=37					)
								config.push_to_hub('''test-config''',  use_auth_token=self._token					)

								lowerCamelCase__		:		Dict		     =BertConfig.from_pretrained(F'''{USER}/test-config'''					)
								for k, v in config.to_dict().items():
											if k != "transformers_version":
														self.assertEqual(lowerCamelCase,  getattr(lowerCamelCase,  lowerCamelCase					)					)

        # Reset repo
								delete_repo(token=self._token,  repo_id='''test-config'''					)

								# Push to hub via save_pretrained
								with tempfile.TemporaryDirectory() as tmp_dir:
											config.save_pretrained(lowerCamelCase,  repo_id='''test-config''',  push_to_hub=lowerCamelCase,  use_auth_token=self._token					)

								lowerCamelCase__		:		Dict		     =BertConfig.from_pretrained(F'''{USER}/test-config'''					)
								for k, v in config.to_dict().items():
											if k != "transformers_version":
														self.assertEqual(lowerCamelCase,  getattr(lowerCamelCase,  lowerCamelCase					)					)



					def 		snake_case	(	self							:  Optional[int]					)-> str:
								lowerCamelCase__		:		str		     =BertConfig(
								    vocab_size=99,  hidden_size=32,  num_hidden_layers=5,  num_attention_heads=4,  intermediate_size=37					)
								config.push_to_hub('''valid_org/test-config-org''',  use_auth_token=self._token					)

								lowerCamelCase__		:		List[str]		     =BertConfig.from_pretrained('''valid_org/test-config-org'''					)
								for k, v in config.to_dict().items():
											if k != "transformers_version":
														self.assertEqual(lowerCamelCase,  getattr(lowerCamelCase,  lowerCamelCase					)					)

        # Reset repo
								delete_repo(token=self._token,  repo_id='''valid_org/test-config-org'''					)

								# Push to hub via save_pretrained
								with tempfile.TemporaryDirectory() as tmp_dir:
											config.save_pretrained(
											    lowerCamelCase,  repo_id='''valid_org/test-config-org''',  push_to_hub=lowerCamelCase,  use_auth_token=self._token					)

								lowerCamelCase__		:		List[str]		     =BertConfig.from_pretrained('''valid_org/test-config-org'''					)
								for k, v in config.to_dict().items():
											if k != "transformers_version":
														self.assertEqual(lowerCamelCase,  getattr(lowerCamelCase,  lowerCamelCase					)					)




					def 		snake_case	(	self							:  Dict					)-> Tuple:
								CustomConfig.register_for_auto_class()
								lowerCamelCase__		:		Tuple		     =CustomConfig(attribute=42					)

								config.push_to_hub('''test-dynamic-config''',  use_auth_token=self._token					)

								# This has added the proper auto_map field to the config
								self.assertDictEqual(config.auto_map,  {'''AutoConfig''': '''custom_configuration.CustomConfig'''}					)

								lowerCamelCase__		:		Any		     =AutoConfig.from_pretrained(F'''{USER}/test-dynamic-config''',  trust_remote_code=lowerCamelCase					)
								# Can't make an isinstance check because the new_config is from the FakeConfig class of a dynamic module
								self.assertEqual(new_config.__class__.__name__,  '''CustomConfig'''					)
								self.assertEqual(new_config.attribute,  42					)





class 	__SCREAMING_SNAKE_CASE     (				unittest.TestCase       ):


					'''simple docstring'''





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

								# attempt to modify each of int/float/bool/str config records and verify they were updated
								lowerCamelCase__		:		str		     =c.n_embd + 1  # int
								lowerCamelCase__		:		str		     =c.resid_pdrop + 1.0  # float
								lowerCamelCase__		:		Tuple		     =not c.scale_attn_weights  # bool
								lowerCamelCase__		:		Dict		     =c.summary_type + '''foo'''  # str
								c.update_from_string(
								    F'''n_embd={n_embd},resid_pdrop={resid_pdrop},scale_attn_weights={scale_attn_weights},summary_type={summary_type}'''					)
								self.assertEqual(lowerCamelCase,  c.n_embd,  '''mismatch for key: n_embd'''					)
								self.assertEqual(lowerCamelCase,  c.resid_pdrop,  '''mismatch for key: resid_pdrop'''					)
								self.assertEqual(lowerCamelCase,  c.scale_attn_weights,  '''mismatch for key: scale_attn_weights'''					)
								self.assertEqual(lowerCamelCase,  c.summary_type,  '''mismatch for key: summary_type'''					)



					def 		snake_case	(	self							:  Union[str, Any]					)-> List[Any]:
								lowerCamelCase__		:		List[str]		     =PretrainedConfig()
								lowerCamelCase__		:		Optional[int]		     =[key for key in base_config.__dict__ if key not in config_common_kwargs]
								# If this part of the test fails, you have arguments to addin config_common_kwargs above.
								self.assertListEqual(
								    lowerCamelCase,  ['''is_encoder_decoder''', '''_name_or_path''', '''_commit_hash''', '''transformers_version''']					)
								lowerCamelCase__		:		List[str]		     =[key for key, value in config_common_kwargs.items() if value == getattr(lowerCamelCase,  lowerCamelCase					)]
								if len(lowerCamelCase					) > 0:
											raise ValueError(
											    '''The following keys are set with the default values in'''
											    ''' `test_configuration_common.config_common_kwargs` pick another value for them:'''
											    F''' {", ".join(lowerCamelCase					)}.'''					)



					def 		snake_case	(	self							:  List[Any]					)-> Any:
								with self.assertRaises(lowerCamelCase					):
											# config is in subfolder, the following should not work without specifying the subfolder
											lowerCamelCase__		:		Optional[Any]		     =BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert-subfolder'''					)

								lowerCamelCase__		:		Tuple		     =BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert-subfolder''',  subfolder='''bert'''					)

								self.assertIsNotNone(lowerCamelCase					)



					def 		snake_case	(	self							:  List[str]					)-> Dict:
								# A mock response for an HTTP head request to emulate server down
								lowerCamelCase__		:		str		     =mock.Mock()
								lowerCamelCase__		:		Optional[int]		     =500
								lowerCamelCase__		:		Optional[int]		     ={}
								lowerCamelCase__		:		Union[str, Any]		     =HTTPError
								lowerCamelCase__		:		str		     ={}

								# Download this model to make sure it's in the cache.
								lowerCamelCase__		:		Optional[Any]		     =BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert'''					)

								# Under the mock environment we get a 500 error when trying to reach the model.
								with mock.patch('''requests.Session.request''',  return_value=lowerCamelCase					) as mock_head:
											lowerCamelCase__		:		Union[str, Any]		     =BertConfig.from_pretrained('''hf-internal-testing/tiny-random-bert'''					)
											# This check we did call the fake head request
											mock_head.assert_called()



					def 		snake_case	(	self							:  Optional[int]					)-> Union[str, Any]:
								# This test is for deprecated behavior and can be removed in v5
								lowerCamelCase__		:		int		     =BertConfig.from_pretrained(
								    '''https://huggingface.co/hf-internal-testing/tiny-random-bert/resolve/main/config.json'''					)



					def 		snake_case	(	self							:  int					)-> Optional[int]:
								lowerCamelCase__		:		List[str]		     =AutoConfig.from_pretrained('''bert-base-cased'''					)
								lowerCamelCase__		:		Union[str, Any]		     =['''config.4.0.0.json''']

								with tempfile.TemporaryDirectory() as tmp_dir:
											configuration.save_pretrained(lowerCamelCase					)
											lowerCamelCase__		:		Optional[Any]		     =2
											json.dump(configuration.to_dict(),  open(os.path.join(lowerCamelCase,  '''config.4.0.0.json'''					),  '''w'''					)					)

											# This should pick the new configuration file as the version of Transformers is > 4.0.0
											lowerCamelCase__		:		Union[str, Any]		     =AutoConfig.from_pretrained(lowerCamelCase					)
											self.assertEqual(new_configuration.hidden_size,  2					)

											# Will need to be adjusted if we reach v42 and this test is still here.
											# Should pick the old configuration file as the version of Transformers is < 4.42.0
											lowerCamelCase__		:		Tuple		     =['''config.42.0.0.json''']
											lowerCamelCase__		:		str		     =768
											configuration.save_pretrained(lowerCamelCase					)
											shutil.move(os.path.join(lowerCamelCase,  '''config.4.0.0.json'''					),  os.path.join(lowerCamelCase,  '''config.42.0.0.json'''					)					)
											lowerCamelCase__		:		List[Any]		     =AutoConfig.from_pretrained(lowerCamelCase					)
											self.assertEqual(new_configuration.hidden_size,  768					)




					def 		snake_case	(	self							:  List[Any]					)-> List[Any]:
								# This repo has two configuration files, one for v4.0.0 and above with a different hidden size.
								lowerCamelCase__		:		List[str]		     ='''hf-internal-testing/test-two-configs'''

								import transformers as new_transformers

								lowerCamelCase__		:		str		     ='''v4.0.0'''
								lowerCamelCase__     ,       lowerCamelCase__		:		Dict		     =new_transformers.models.auto.AutoConfig.from_pretrained(
								    lowerCamelCase,  return_unused_kwargs=lowerCamelCase					)
								self.assertEqual(new_configuration.hidden_size,  2					)
								# This checks `_configuration_file` ia not kept in the kwargs by mistake.
								self.assertDictEqual(lowerCamelCase,  {}					)

								# Testing an older version by monkey-patching the version in the module it's used.
								import transformers as old_transformers

								lowerCamelCase__		:		Dict		     ='''v3.0.0'''
								lowerCamelCase__		:		Tuple		     =old_transformers.models.auto.AutoConfig.from_pretrained(lowerCamelCase					)
								self.assertEqual(old_configuration.hidden_size,  768					)









"""simple docstring"""






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

import os
from pathlib import Path






def 					snake_case__       (		__lowerCamelCase    :   Union[str, Any]							,		__lowerCamelCase    :   int							,		__lowerCamelCase    :   Tuple							,		__lowerCamelCase    :   Union[str, Any]     ):
			"""simple docstring"""
			lowerCamelCase__		:		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]
			lowerCamelCase__		:		Optional[Any]		     ={
			    '''wmt16-en-de-dist-12-1''': [28.3, 27.52],
			    '''wmt16-en-de-dist-6-1''': [27.4, 27.11],
			    '''wmt16-en-de-12-1''': [26.9, 25.75],
			}
			lowerCamelCase__		:		Any		     =f'''{src_lang}-{tgt_lang}'''

			lowerCamelCase__		:		Any		     =f'''
---
language:
- {src_lang}
- {tgt_lang}
thumbnail:
tags:
- translation
- wmt16
- allenai
license: apache-2.0
datasets:
- wmt16
metrics:
- bleu
---

# FSMT

## Model description

This is a ported version of fairseq-based [wmt16 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).

All 3 models are available:

* [wmt16-en-de-dist-12-1](https://huggingface.co/allenai/wmt16-en-de-dist-12-1)
* [wmt16-en-de-dist-6-1](https://huggingface.co/allenai/wmt16-en-de-dist-6-1)
* [wmt16-en-de-12-1](https://huggingface.co/allenai/wmt16-en-de-12-1)


## 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   | fairseq | transformers
-------|---------|----------
{model_name}  | {scores[model_name][0]} | {scores[model_name][1]}

The score is slightly below the score reported in the paper, as the researchers don\'t use `sacrebleu` and measure the score on tokenized outputs. `transformers` score was measured using `sacrebleu` on detokenized outputs.

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 wmt16 -l $PAIR --echo src > $DATA_DIR/val.source
sacrebleu -t wmt16 -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/wmt16/)
- [test set](http://matrix.statmt.org/test_sets/newstest2016.tgz?1504722372)


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


# make sure we are under the root of the project
_lowercase			:			List[str]										=						Path(__file__).resolve().parent.parent.parent
_lowercase			:			Dict										=						repo_dir / "model_cards"

for model_name in ["wmt16-en-de-dist-12-1", "wmt16-en-de-dist-6-1", "wmt16-en-de-12-1"]:
		_lowercase			:			int										=						model_cards_dir / "allenai" / model_name
		write_model_card(model_card_dir, src_lang="en", tgt_lang="de", model_name=model_name)




