


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

import os
from pathlib import Path




def    a   (							A__      ,    A__      ,    A__      ,    A__							)	-> int:




      '''simple docstring'''

      SCREAMING_SNAKE_CASE__       :  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]
      SCREAMING_SNAKE_CASE__       :  str						     =		{
          '''wmt16-en-de-dist-12-1''': [2_8.3, 2_7.5_2],
          '''wmt16-en-de-dist-6-1''': [2_7.4, 2_7.1_1],
          '''wmt16-en-de-12-1''': [2_6.9, 2_5.7_5],
      }
      SCREAMING_SNAKE_CASE__       :  int						     =		f"""{src_lang}-{tgt_lang}"""

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


# make sure we are under the root of the project
a_ :Optional[Any]  							=			Path(__file__).resolve().parent.parent.parent
a_ :Union[str, Any]  							=			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"]:
    a_ :Union[str, Any]  							=			model_cards_dir / 'allenai' / model_name
    write_model_card(model_card_dir, src_lang='en', tgt_lang='de', model_name=model_name)










'''simple docstring'''
import gc
import unittest

import numpy as np
import torch

from diffusers import StableDiffusionKDiffusionPipeline
from diffusers.utils import slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu


enable_full_determinism()






@slow
@require_torch_gpu
class        lowerCAmelCase_  (     unittest.TestCase	):






       def   UpperCamelCase						( self   )->      Optional[int]:
            # clean up the VRAM after each test
            super().tearDown()
            gc.collect()
            torch.cuda.empty_cache()






       def   UpperCamelCase						( self   )->      Union[str, Any]:
            _A				=							StableDiffusionKDiffusionPipeline.from_pretrained('CompVis/stable-diffusion-v1-4'   )
            _A				=							sd_pipe.to(_UpperCamelCase   )
            sd_pipe.set_progress_bar_config(disable=_UpperCamelCase   )

            sd_pipe.set_scheduler('sample_euler'   )

            _A				=							'A painting of a squirrel eating a burger'
            _A				=							torch.manual_seed(0   )
            _A				=							sd_pipe([prompt]			,     generator=_UpperCamelCase			,     guidance_scale=9.0			,     num_inference_steps=20			,     output_type='np'   )

            _A				=							output.images

            _A				=							image[0, -3:, -3:, -1]

            assert image.shape == (1, 512, 512, 3)
            _A				=							np.array([0.0447, 0.0492, 0.0468, 0.0408, 0.0383, 0.0408, 0.0354, 0.0380, 0.0339]   )

            assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-2






       def   UpperCamelCase						( self   )->      Optional[Any]:
            _A				=							StableDiffusionKDiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base'   )
            _A				=							sd_pipe.to(_UpperCamelCase   )
            sd_pipe.set_progress_bar_config(disable=_UpperCamelCase   )

            sd_pipe.set_scheduler('sample_euler'   )

            _A				=							'A painting of a squirrel eating a burger'
            _A				=							torch.manual_seed(0   )
            _A				=							sd_pipe([prompt]			,     generator=_UpperCamelCase			,     guidance_scale=9.0			,     num_inference_steps=20			,     output_type='np'   )

            _A				=							output.images

            _A				=							image[0, -3:, -3:, -1]

            assert image.shape == (1, 512, 512, 3)
            _A				=							np.array([0.1237, 0.1320, 0.1438, 0.1359, 0.1390, 0.1132, 0.1277, 0.1175, 0.1112]   )

            assert np.abs(image_slice.flatten() - expected_slice   ).max() < 5e-1






       def   UpperCamelCase						( self   )->      Optional[int]:
            _A				=							StableDiffusionKDiffusionPipeline.from_pretrained('stabilityai/stable-diffusion-2-1-base'   )
            _A				=							sd_pipe.to(_UpperCamelCase   )
            sd_pipe.set_progress_bar_config(disable=_UpperCamelCase   )

            sd_pipe.set_scheduler('sample_dpmpp_2m'   )

            _A				=							'A painting of a squirrel eating a burger'
            _A				=							torch.manual_seed(0   )
            _A				=							sd_pipe(
                [prompt]			,     generator=_UpperCamelCase			,     guidance_scale=7.5			,     num_inference_steps=15			,     output_type='np'			,     use_karras_sigmas=_UpperCamelCase			,     )

            _A				=							output.images

            _A				=							image[0, -3:, -3:, -1]

            assert image.shape == (1, 512, 512, 3)
            _A				=							np.array(
                [0.1138_1689, 0.1211_2921, 0.138_9457, 0.1254_9606, 0.124_4964, 0.1083_1517, 0.1156_2866, 0.1086_7816, 0.1049_9048]   )

            assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1e-2





