





import sacrebleu as scb
from packaging import version
from sacrebleu import TER

import datasets


UpperCAmelCase_ 							=       """\
@inproceedings{snover-etal-2006-study,
    title = \"A Study of Translation Edit Rate with Targeted Human Annotation\",
    author = \"Snover, Matthew  and
      Dorr, Bonnie  and
      Schwartz, Rich  and
      Micciulla, Linnea  and
      Makhoul, John\",
    booktitle = \"Proceedings of the 7th Conference of the Association for Machine Translation in the Americas: Technical Papers\",
    month = aug # \" 8-12\",
    year = \"2006\",
    address = \"Cambridge, Massachusetts, USA\",
    publisher = \"Association for Machine Translation in the Americas\",
    url = \"https://aclanthology.org/2006.amta-papers.25\",
    pages = \"223--231\",
}
@inproceedings{post-2018-call,
    title = \"A Call for Clarity in Reporting {BLEU} Scores\",
    author = \"Post, Matt\",
    booktitle = \"Proceedings of the Third Conference on Machine Translation: Research Papers\",
    month = oct,
    year = \"2018\",
    address = \"Belgium, Brussels\",
    publisher = \"Association for Computational Linguistics\",
    url = \"https://www.aclweb.org/anthology/W18-6319\",
    pages = \"186--191\",
}
"""

UpperCAmelCase_ 							=       """\
TER (Translation Edit Rate, also called Translation Error Rate) is a metric to quantify the edit operations that a
hypothesis requires to match a reference translation. We use the implementation that is already present in sacrebleu
(https://github.com/mjpost/sacreBLEU#ter), which in turn is inspired by the TERCOM implementation, which can be found
here: https://github.com/jhclark/tercom.

The implementation here is slightly different from sacrebleu in terms of the required input format. The length of
the references and hypotheses lists need to be the same, so you may need to transpose your references compared to
sacrebleu's required input format. See https://github.com/huggingface/datasets/issues/3154#issuecomment-950746534

See the README.md file at https://github.com/mjpost/sacreBLEU#ter for more information.
"""

UpperCAmelCase_ 							=       """
Produces TER scores alongside the number of edits and reference length.

Args:
    predictions (list of str): The system stream (a sequence of segments).
    references (list of list of str): A list of one or more reference streams (each a sequence of segments).
    normalized (boolean): If `True`, applies basic tokenization and normalization to sentences. Defaults to `False`.
    ignore_punct (boolean): If `True`, applies basic tokenization and normalization to sentences. Defaults to `False`.
    support_zh_ja_chars (boolean): If `True`, tokenization/normalization supports processing of Chinese characters,
                                    as well as Japanese Kanji, Hiragana, Katakana, and Phonetic Extensions of Katakana.
                                    Only applies if `normalized = True`. Defaults to `False`.
    case_sensitive (boolean): If `False`, makes all predictions and references lowercase to ignore differences in case. Defaults to `False`.

Returns:
    'score' (float): TER score (num_edits / sum_ref_lengths * 100)
    'num_edits' (int): The cumulative number of edits
    'ref_length' (float): The cumulative average reference length

Examples:
    Example 1:
        >>> predictions = [\"does this sentence match??\",
        ...                     \"what about this sentence?\",
        ...                     \"What did the TER metric user say to the developer?\"]
        >>> references = [[\"does this sentence match\", \"does this sentence match!?!\"],
        ...             [\"wHaT aBoUt ThIs SeNtEnCe?\", \"wHaT aBoUt ThIs SeNtEnCe?\"],
        ...             [\"Your jokes are...\", \"...TERrible\"]]
        >>> ter = datasets.load_metric(\"ter\")
        >>> results = ter.compute(predictions=predictions,
        ...                         references=references,
        ...                         case_sensitive=True)
        >>> print(results)
        {'score': 150.0, 'num_edits': 15, 'ref_length': 10.0}

    Example 2:
        >>> predictions = [\"does this sentence match??\",
        ...                     \"what about this sentence?\"]
        >>> references = [[\"does this sentence match\", \"does this sentence match!?!\"],
        ...             [\"wHaT aBoUt ThIs SeNtEnCe?\", \"wHaT aBoUt ThIs SeNtEnCe?\"]]
        >>> ter = datasets.load_metric(\"ter\")
        >>> results = ter.compute(predictions=predictions,
        ...                         references=references,
        ...                         case_sensitive=True)
        >>> print(results)
        {'score': 62.5, 'num_edits': 5, 'ref_length': 8.0}

    Example 3:
        >>> predictions = [\"does this sentence match??\",
        ...                     \"what about this sentence?\"]
        >>> references = [[\"does this sentence match\", \"does this sentence match!?!\"],
        ...             [\"wHaT aBoUt ThIs SeNtEnCe?\", \"wHaT aBoUt ThIs SeNtEnCe?\"]]
        >>> ter = datasets.load_metric(\"ter\")
        >>> results = ter.compute(predictions=predictions,
        ...                         references=references,
        ...                         normalized=True,
        ...                         case_sensitive=True)
        >>> print(results)
        {'score': 57.14285714285714, 'num_edits': 6, 'ref_length': 10.5}

    Example 4:
        >>> predictions = [\"does this sentence match??\",
        ...                     \"what about this sentence?\"]
        >>> references = [[\"does this sentence match\", \"does this sentence match!?!\"],
        ...             [\"wHaT aBoUt ThIs SeNtEnCe?\", \"wHaT aBoUt ThIs SeNtEnCe?\"]]
        >>> ter = datasets.load_metric(\"ter\")
        >>> results = ter.compute(predictions=predictions,
        ...                         references=references,
        ...                         ignore_punct=True,
        ...                         case_sensitive=False)
        >>> print(results)
        {'score': 0.0, 'num_edits': 0, 'ref_length': 8.0}

    Example 5:
        >>> predictions = [\"does this sentence match??\",
        ...                    \"what about this sentence?\",
        ...                    \"What did the TER metric user say to the developer?\"]
        >>> references = [[\"does this sentence match\", \"does this sentence match!?!\"],
        ...             [\"wHaT aBoUt ThIs SeNtEnCe?\", \"wHaT aBoUt ThIs SeNtEnCe?\"],
        ...             [\"Your jokes are...\", \"...TERrible\"]]
        >>> ter = datasets.load_metric(\"ter\")
        >>> results = ter.compute(predictions=predictions,
        ...                         references=references,
        ...                         ignore_punct=True,
        ...                         case_sensitive=False)
        >>> print(results)
        {'score': 100.0, 'num_edits': 10, 'ref_length': 10.0}
"""
@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION							,					_KWARGS_DESCRIPTION   )
class      UpperCamelCase_						(					datasets.Metric   ):




					def 		lowerCAmelCase     (						self					)						->							Optional[Any]:


										if version.parse(scb.__version__					) < version.parse('1.4.12'					):
															raise ImportWarning(
															    'To use `sacrebleu`, the module `sacrebleu>=1.4.12` is required, and the current version of `sacrebleu` doesn\'t match this condition.\n'
															    'You can install it with `pip install "sacrebleu>=1.4.12"`.'					)
										return datasets.MetricInfo(
										    description=_DESCRIPTION			,  citation=_CITATION			,  homepage='http://www.cs.umd.edu/~snover/tercom/'			,  inputs_description=_KWARGS_DESCRIPTION			,  features=datasets.Features(
										        {
										            'predictions': datasets.Value('string'			,  id='sequence'					),
										            'references': datasets.Sequence(datasets.Value('string'			,  id='sequence'					)			,  id='references'					),
										        }					)			,  codebase_urls=['https://github.com/mjpost/sacreBLEU#ter']			,  reference_urls=[
										        'https://github.com/jhclark/tercom',
										    ]			,  )






					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_ = False			,  lowerCAmelCase_ = False			,  lowerCAmelCase_ = False			,  lowerCAmelCase_ = False			,  )						->							Dict:
										_snake_case													=			len(references[0]					)
										if any(len(_A					) != references_per_prediction for refs in references					):
															raise ValueError('Sacrebleu requires the same number of references for each prediction'					)
										_snake_case													=			[[refs[i] for refs in references] for i in range(_A					)]

										_snake_case													=			TER(
										    normalized=_A			,  no_punct=_A			,  asian_support=_A			,  case_sensitive=_A			,  )
										_snake_case													=			sb_ter.corpus_score(_A			,  _A					)

										return {"score": output.score, "num_edits": output.num_edits, "ref_length": output.ref_length}










import math

import torch
from torch import nn

from ..configuration_utils import ConfigMixin, register_to_config
from .attention_processor import Attention
from .embeddings import get_timestep_embedding
from .modeling_utils import ModelMixin
class      UpperCamelCase_						(					_lowerCamelCase							,					_lowerCamelCase   ):




					@register_to_config
					def __init__(						self			,  lowerCAmelCase_ = 128			,  lowerCAmelCase_ = 256			,  lowerCAmelCase_ = 20_00.0			,  lowerCAmelCase_ = 768			,  lowerCAmelCase_ = 12			,  lowerCAmelCase_ = 12			,  lowerCAmelCase_ = 64			,  lowerCAmelCase_ = 2048			,  lowerCAmelCase_ = 0.1			,  )						->							Union[str, Any]:
										super().__init__()

										_snake_case													=			nn.Sequential(
										    nn.Linear(lowerCAmelCase_			,  d_model * 4			,  bias=lowerCAmelCase_					)			,  nn.SiLU()			,  nn.Linear(d_model * 4			,  d_model * 4			,  bias=lowerCAmelCase_					)			,  nn.SiLU()			,  )

										_snake_case													=			nn.Embedding(lowerCAmelCase_			,  lowerCAmelCase_					)
										_snake_case													=			False

										_snake_case													=			nn.Linear(lowerCAmelCase_			,  lowerCAmelCase_			,  bias=lowerCAmelCase_					)

										_snake_case													=			nn.Dropout(p=lowerCAmelCase_					)

										_snake_case													=			nn.ModuleList()
										for lyr_num in range(lowerCAmelCase_					):
															# FiLM conditional T5 decoder
															_snake_case													=			DecoderLayer(d_model=lowerCAmelCase_			,  d_kv=lowerCAmelCase_			,  num_heads=lowerCAmelCase_			,  d_ff=lowerCAmelCase_			,  dropout_rate=lowerCAmelCase_					)
															self.decoders.append(lowerCAmelCase_					)

										_snake_case													=			TaLayerNorm(lowerCAmelCase_					)

										_snake_case													=			nn.Dropout(p=lowerCAmelCase_					)
										_snake_case													=			nn.Linear(lowerCAmelCase_			,  lowerCAmelCase_			,  bias=lowerCAmelCase_					)




					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							Tuple:
										_snake_case													=			torch.mul(query_input.unsqueeze(-1					)			,  key_input.unsqueeze(-2					)					)
										return mask.unsqueeze(-3					)






					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							Optional[Any]:
										_snake_case							,       _snake_case							,       _snake_case													=			decoder_input_tokens.shape
										assert decoder_noise_time.shape == (batch,)

										# decoder_noise_time is in [0, 1), so rescale to expected timing range.
										_snake_case													=			get_timestep_embedding(
										    decoder_noise_time * self.config.max_decoder_noise_time			,  embedding_dim=self.config.d_model			,  max_period=self.config.max_decoder_noise_time			,  ).to(dtype=self.dtype					)

										_snake_case													=			self.conditioning_emb(lowerCAmelCase_					).unsqueeze(1					)

										assert conditioning_emb.shape == (batch, 1, self.config.d_model * 4)

										_snake_case													=			decoder_input_tokens.shape[1]

										# If we want to use relative positions for audio context, we can just offset
										# this sequence by the length of encodings_and_masks.
										_snake_case													=			torch.broadcast_to(
										    torch.arange(lowerCAmelCase_			,  device=decoder_input_tokens.device					)			,  (batch, seq_length)			,  )

										_snake_case													=			self.position_encoding(lowerCAmelCase_					)

										_snake_case													=			self.continuous_inputs_projection(lowerCAmelCase_					)
										inputs += position_encodings
										_snake_case													=			self.dropout(lowerCAmelCase_					)

										# decoder: No padding present.
										_snake_case													=			torch.ones(
										    decoder_input_tokens.shape[:2]			,  device=decoder_input_tokens.device			,  dtype=inputs.dtype					)

										# Translate encoding masks to encoder-decoder masks.
										_snake_case													=			[(x, self.encoder_decoder_mask(lowerCAmelCase_			,  lowerCAmelCase_					)) for x, y in encodings_and_masks]

										# cross attend style: concat encodings
										_snake_case													=			torch.cat([x[0] for x in encodings_and_encdec_masks]			,  dim=1					)
										_snake_case													=			torch.cat([x[1] for x in encodings_and_encdec_masks]			,  dim=-1					)

										for lyr in self.decoders:
															_snake_case													=			lyr(
															    lowerCAmelCase_			,  conditioning_emb=lowerCAmelCase_			,  encoder_hidden_states=lowerCAmelCase_			,  encoder_attention_mask=lowerCAmelCase_			,  )[0]

										_snake_case													=			self.decoder_norm(lowerCAmelCase_					)
										_snake_case													=			self.post_dropout(lowerCAmelCase_					)

										_snake_case													=			self.spec_out(lowerCAmelCase_					)
										return spec_out





class      UpperCamelCase_						(					nn.Module   ):




					def __init__(						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_=1E-6					)						->							Tuple:
										super().__init__()
										_snake_case													=			nn.ModuleList()

										# cond self attention: layer 0
										self.layer.append(
										    TaLayerSelfAttentionCond(d_model=lowerCAmelCase_			,  d_kv=lowerCAmelCase_			,  num_heads=lowerCAmelCase_			,  dropout_rate=lowerCAmelCase_					)					)

										# cross attention: layer 1
										self.layer.append(
										    TaLayerCrossAttention(
										        d_model=lowerCAmelCase_			,  d_kv=lowerCAmelCase_			,  num_heads=lowerCAmelCase_			,  dropout_rate=lowerCAmelCase_			,  layer_norm_epsilon=lowerCAmelCase_			,  )					)

										# Film Cond MLP + dropout: last layer
										self.layer.append(
										    TaLayerFFCond(d_model=lowerCAmelCase_			,  d_ff=lowerCAmelCase_			,  dropout_rate=lowerCAmelCase_			,  layer_norm_epsilon=lowerCAmelCase_					)					)






					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_=None			,  lowerCAmelCase_=None			,  lowerCAmelCase_=None			,  lowerCAmelCase_=None			,  lowerCAmelCase_=None			,  )						->							Tuple:
										_snake_case													=			self.layer[0](
										    lowerCAmelCase_			,  conditioning_emb=lowerCAmelCase_			,  attention_mask=lowerCAmelCase_			,  )

										if encoder_hidden_states is not None:
															_snake_case													=			torch.where(encoder_attention_mask > 0			,  0			,  -1E10					).to(
															    encoder_hidden_states.dtype					)

															_snake_case													=			self.layer[1](
															    lowerCAmelCase_			,  key_value_states=lowerCAmelCase_			,  attention_mask=lowerCAmelCase_			,  )

										# Apply Film Conditional Feed Forward layer
										_snake_case													=			self.layer[-1](lowerCAmelCase_			,  lowerCAmelCase_					)

										return (hidden_states,)





class      UpperCamelCase_						(					nn.Module   ):




					def __init__(						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							Tuple:
										super().__init__()
										_snake_case													=			TaLayerNorm(lowerCAmelCase_					)
										_snake_case													=			TaFiLMLayer(in_features=d_model * 4			,  out_features=lowerCAmelCase_					)
										_snake_case													=			Attention(query_dim=lowerCAmelCase_			,  heads=lowerCAmelCase_			,  dim_head=lowerCAmelCase_			,  out_bias=lowerCAmelCase_			,  scale_qk=lowerCAmelCase_					)
										_snake_case													=			nn.Dropout(lowerCAmelCase_					)






					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_=None			,  lowerCAmelCase_=None			,  )						->							str:
										# pre_self_attention_layer_norm
										_snake_case													=			self.layer_norm(lowerCAmelCase_					)

										if conditioning_emb is not None:
															_snake_case													=			self.FiLMLayer(lowerCAmelCase_			,  lowerCAmelCase_					)

										# Self-attention block
										_snake_case													=			self.attention(lowerCAmelCase_					)

										_snake_case													=			hidden_states + self.dropout(lowerCAmelCase_					)

										return hidden_states





class      UpperCamelCase_						(					nn.Module   ):




					def __init__(						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							str:
										super().__init__()
										_snake_case													=			Attention(query_dim=lowerCAmelCase_			,  heads=lowerCAmelCase_			,  dim_head=lowerCAmelCase_			,  out_bias=lowerCAmelCase_			,  scale_qk=lowerCAmelCase_					)
										_snake_case													=			TaLayerNorm(lowerCAmelCase_			,  eps=lowerCAmelCase_					)
										_snake_case													=			nn.Dropout(lowerCAmelCase_					)






					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_=None			,  lowerCAmelCase_=None			,  )						->							Dict:
										_snake_case													=			self.layer_norm(lowerCAmelCase_					)
										_snake_case													=			self.attention(
										    lowerCAmelCase_			,  encoder_hidden_states=lowerCAmelCase_			,  attention_mask=attention_mask.squeeze(1					)			,  )
										_snake_case													=			hidden_states + self.dropout(lowerCAmelCase_					)
										return layer_output





class      UpperCamelCase_						(					nn.Module   ):




					def __init__(						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							List[str]:
										super().__init__()
										_snake_case													=			TaDenseGatedActDense(d_model=lowerCAmelCase_			,  d_ff=lowerCAmelCase_			,  dropout_rate=lowerCAmelCase_					)
										_snake_case													=			TaFiLMLayer(in_features=d_model * 4			,  out_features=lowerCAmelCase_					)
										_snake_case													=			TaLayerNorm(lowerCAmelCase_			,  eps=lowerCAmelCase_					)
										_snake_case													=			nn.Dropout(lowerCAmelCase_					)






					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_=None					)						->							Union[str, Any]:
										_snake_case													=			self.layer_norm(lowerCAmelCase_					)
										if conditioning_emb is not None:
															_snake_case													=			self.film(lowerCAmelCase_			,  lowerCAmelCase_					)

										_snake_case													=			self.DenseReluDense(lowerCAmelCase_					)
										_snake_case													=			hidden_states + self.dropout(lowerCAmelCase_					)
										return hidden_states





class      UpperCamelCase_						(					nn.Module   ):




					def __init__(						self			,  lowerCAmelCase_			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							Union[str, Any]:
										super().__init__()
										_snake_case													=			nn.Linear(lowerCAmelCase_			,  lowerCAmelCase_			,  bias=lowerCAmelCase_					)
										_snake_case													=			nn.Linear(lowerCAmelCase_			,  lowerCAmelCase_			,  bias=lowerCAmelCase_					)
										_snake_case													=			nn.Linear(lowerCAmelCase_			,  lowerCAmelCase_			,  bias=lowerCAmelCase_					)
										_snake_case													=			nn.Dropout(lowerCAmelCase_					)
										_snake_case													=			NewGELUActivation()






					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_					)						->							Any:
										_snake_case													=			self.act(self.wi_a(lowerCAmelCase_					)					)
										_snake_case													=			self.wi_a(lowerCAmelCase_					)
										_snake_case													=			hidden_gelu * hidden_linear
										_snake_case													=			self.dropout(lowerCAmelCase_					)

										_snake_case													=			self.wo(lowerCAmelCase_					)
										return hidden_states





class      UpperCamelCase_						(					nn.Module   ):




					def __init__(						self			,  lowerCAmelCase_			,  lowerCAmelCase_=1E-6					)						->							str:
										super().__init__()
										_snake_case													=			nn.Parameter(torch.ones(lowerCAmelCase_					)					)
										_snake_case													=			eps






					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_					)						->							int:
										# T5 uses a layer_norm which only scales and doesn't shift, which is also known as Root Mean
										# Square Layer Normalization https://arxiv.org/abs/1910.07467 thus variance is calculated
										# w/o mean and there is no bias. Additionally we want to make sure that the accumulation for
										# half-precision inputs is done in fp32

										_snake_case													=			hidden_states.to(torch.floataa					).pow(2					).mean(-1			,  keepdim=lowerCAmelCase_					)
										_snake_case													=			hidden_states * torch.rsqrt(variance + self.variance_epsilon					)

										# convert into half-precision if necessary
										if self.weight.dtype in [torch.floataa, torch.bfloataa]:
															_snake_case													=			hidden_states.to(self.weight.dtype					)

										return self.weight * hidden_states





class      UpperCamelCase_						(					nn.Module   ):




					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_					)						->							torch.Tensor:
										return 0.5 * input * (1.0 + torch.tanh(math.sqrt(2.0 / math.pi					) * (input + 0.04_47_15 * torch.pow(lowerCAmelCase_			,  3.0					))					))





class      UpperCamelCase_						(					nn.Module   ):




					def __init__(						self			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							Any:
										super().__init__()
										_snake_case													=			nn.Linear(lowerCAmelCase_			,  out_features * 2			,  bias=lowerCAmelCase_					)






					def 		lowerCAmelCase     (						self			,  lowerCAmelCase_			,  lowerCAmelCase_					)						->							Optional[Any]:
										_snake_case													=			self.scale_bias(lowerCAmelCase_					)
										_snake_case							,       _snake_case													=			torch.chunk(lowerCAmelCase_			,  2			,  -1					)
										_snake_case													=			x * (1 + scale) + shift
										return x



