

'''simple docstring'''



import itertools
import json
import os
import unittest

from transformers import AddedToken, RobertaTokenizer, RobertaTokenizerFast
from transformers.models.roberta.tokenization_roberta import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin







@require_tokenizers
class 		lowerCAmelCase__  ( a					,   unittest.TestCase   ):



 """simple docstring"""



 lowerCAmelCase__       = RobertaTokenizer
 lowerCAmelCase__       = RobertaTokenizerFast
 lowerCAmelCase__       = True
 lowerCAmelCase__       = {"cls_token": "<s>"}
 def  UpperCAmelCase__						(						self   :			Dict     )    ->					Any:


      """simple docstring"""




      super().setUp()

      # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
      __SCREAMING_SNAKE_CASE      = [
          """l""",
          """o""",
          """w""",
          """e""",
          """r""",
          """s""",
          """t""",
          """i""",
          """d""",
          """n""",
          """\u0120""",
          """\u0120l""",
          """\u0120n""",
          """\u0120lo""",
          """\u0120low""",
          """er""",
          """\u0120lowest""",
          """\u0120newer""",
          """\u0120wider""",
          """<unk>""",
      ]
      __SCREAMING_SNAKE_CASE      = dict(zip(__SCREAMING_SNAKE_CASE   ,				range(len(__SCREAMING_SNAKE_CASE     )     )     )     )
      __SCREAMING_SNAKE_CASE      = ["""#version: 0.2""", """\u0120 l""", """\u0120l o""", """\u0120lo w""", """e r""", """"""]
      __SCREAMING_SNAKE_CASE      = {"""unk_token""": """<unk>"""}

      __SCREAMING_SNAKE_CASE      = os.path.join(self.tmpdirname   ,				VOCAB_FILES_NAMES["""vocab_file"""]     )
      __SCREAMING_SNAKE_CASE      = os.path.join(self.tmpdirname   ,				VOCAB_FILES_NAMES["""merges_file"""]     )
      with open(self.vocab_file   ,				"""w"""   ,				encoding="""utf-8"""     ) as fp:
           fp.write(json.dumps(__SCREAMING_SNAKE_CASE     ) + """\n"""     )
      with open(self.merges_file   ,				"""w"""   ,				encoding="""utf-8"""     ) as fp:
           fp.write("""\n""".join(__SCREAMING_SNAKE_CASE     )     )
 def  UpperCAmelCase__						(						self   :			List[Any]   ,				**__SCREAMING_SNAKE_CASE   :			int     )    ->					Optional[int]:


      """simple docstring"""




      kwargs.update(self.special_tokens_map     )
      return self.tokenizer_class.from_pretrained(self.tmpdirname   ,				**__SCREAMING_SNAKE_CASE     )
 def  UpperCAmelCase__						(						self   :			str   ,				**__SCREAMING_SNAKE_CASE   :			Optional[Any]     )    ->					Any:


      """simple docstring"""




      kwargs.update(self.special_tokens_map     )
      return RobertaTokenizerFast.from_pretrained(self.tmpdirname   ,				**__SCREAMING_SNAKE_CASE     )
 def  UpperCAmelCase__						(						self   :			List[Any]   ,				__SCREAMING_SNAKE_CASE   :			Tuple     )    ->					Optional[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = """lower newer"""
      __SCREAMING_SNAKE_CASE      = """lower newer"""
      return input_text, output_text
 def  UpperCAmelCase__						(						self   :			int     )    ->					List[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.tokenizer_class(self.vocab_file   ,				self.merges_file   ,				**self.special_tokens_map     )
      __SCREAMING_SNAKE_CASE      = """lower newer"""
      __SCREAMING_SNAKE_CASE      = ["""l""", """o""", """w""", """er""", """\u0120""", """n""", """e""", """w""", """er"""]
      __SCREAMING_SNAKE_CASE      = tokenizer.tokenize(__SCREAMING_SNAKE_CASE     )  # , add_prefix_space=True)
      self.assertListEqual(__SCREAMING_SNAKE_CASE   ,				__SCREAMING_SNAKE_CASE     )

      __SCREAMING_SNAKE_CASE      = tokens + [tokenizer.unk_token]
      __SCREAMING_SNAKE_CASE      = [0, 1, 2, 15, 10, 9, 3, 2, 15, 19]
      self.assertListEqual(tokenizer.convert_tokens_to_ids(__SCREAMING_SNAKE_CASE     )   ,				__SCREAMING_SNAKE_CASE     )
 def  UpperCAmelCase__						(						self   :			Tuple     )    ->					List[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.get_tokenizer()

      self.assertListEqual(tokenizer.encode("""Hello world!"""   ,				add_special_tokens=__SCREAMING_SNAKE_CASE     )   ,				[0, 31_414, 232, 328, 2]     )
      self.assertListEqual(
          tokenizer.encode("""Hello world! cécé herlolip 418"""   ,				add_special_tokens=__SCREAMING_SNAKE_CASE     )   ,				[0, 31_414, 232, 328, 740, 1_140, 12_695, 69, 46_078, 1_588, 2]   ,				)
 @slow
 def  UpperCAmelCase__						(						self   :			Tuple     )    ->					List[Any]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.tokenizer_class.from_pretrained("""roberta-base"""     )

      __SCREAMING_SNAKE_CASE      = tokenizer.encode("""sequence builders"""   ,				add_special_tokens=__SCREAMING_SNAKE_CASE     )
      __SCREAMING_SNAKE_CASE      = tokenizer.encode("""multi-sequence build"""   ,				add_special_tokens=__SCREAMING_SNAKE_CASE     )

      __SCREAMING_SNAKE_CASE      = tokenizer.encode(
          """sequence builders"""   ,				add_special_tokens=__SCREAMING_SNAKE_CASE   ,				add_prefix_space=__SCREAMING_SNAKE_CASE     )
      __SCREAMING_SNAKE_CASE      = tokenizer.encode(
          """sequence builders"""   ,				"""multi-sequence build"""   ,				add_special_tokens=__SCREAMING_SNAKE_CASE   ,				add_prefix_space=__SCREAMING_SNAKE_CASE     )

      __SCREAMING_SNAKE_CASE      = tokenizer.build_inputs_with_special_tokens(__SCREAMING_SNAKE_CASE     )
      __SCREAMING_SNAKE_CASE      = tokenizer.build_inputs_with_special_tokens(__SCREAMING_SNAKE_CASE   ,				__SCREAMING_SNAKE_CASE     )

      assert encoded_sentence == encoded_text_from_decode
      assert encoded_pair == encoded_pair_from_decode
 def  UpperCAmelCase__						(						self   :			Union[str, Any]     )    ->					Tuple:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = self.get_tokenizer()

      __SCREAMING_SNAKE_CASE      = """Encode this sequence."""
      __SCREAMING_SNAKE_CASE      = tokenizer.byte_encoder[""" """.encode("""utf-8"""     )[0]]

      # Testing encoder arguments
      __SCREAMING_SNAKE_CASE      = tokenizer.encode(__SCREAMING_SNAKE_CASE   ,				add_special_tokens=__SCREAMING_SNAKE_CASE   ,				add_prefix_space=__SCREAMING_SNAKE_CASE     )
      __SCREAMING_SNAKE_CASE      = tokenizer.convert_ids_to_tokens(encoded[0]     )[0]
      self.assertNotEqual(__SCREAMING_SNAKE_CASE   ,				__SCREAMING_SNAKE_CASE     )

      __SCREAMING_SNAKE_CASE      = tokenizer.encode(__SCREAMING_SNAKE_CASE   ,				add_special_tokens=__SCREAMING_SNAKE_CASE   ,				add_prefix_space=__SCREAMING_SNAKE_CASE     )
      __SCREAMING_SNAKE_CASE      = tokenizer.convert_ids_to_tokens(encoded[0]     )[0]
      self.assertEqual(__SCREAMING_SNAKE_CASE   ,				__SCREAMING_SNAKE_CASE     )

      tokenizer.add_special_tokens({"""bos_token""": """<s>"""}     )
      __SCREAMING_SNAKE_CASE      = tokenizer.encode(__SCREAMING_SNAKE_CASE   ,				add_special_tokens=__SCREAMING_SNAKE_CASE     )
      __SCREAMING_SNAKE_CASE      = tokenizer.convert_ids_to_tokens(encoded[1]     )[0]
      self.assertNotEqual(__SCREAMING_SNAKE_CASE   ,				__SCREAMING_SNAKE_CASE     )

      # Testing spaces after special tokens
      __SCREAMING_SNAKE_CASE      = """<mask>"""
      tokenizer.add_special_tokens(
          {"""mask_token""": AddedToken(__SCREAMING_SNAKE_CASE   ,				lstrip=__SCREAMING_SNAKE_CASE   ,				rstrip=__SCREAMING_SNAKE_CASE     )}     )  # mask token has a left space
      __SCREAMING_SNAKE_CASE      = tokenizer.convert_tokens_to_ids(__SCREAMING_SNAKE_CASE     )

      __SCREAMING_SNAKE_CASE      = """Encode <mask> sequence"""
      __SCREAMING_SNAKE_CASE      = """Encode <mask>sequence"""

      __SCREAMING_SNAKE_CASE      = tokenizer.encode(__SCREAMING_SNAKE_CASE     )
      __SCREAMING_SNAKE_CASE      = encoded.index(__SCREAMING_SNAKE_CASE     )
      __SCREAMING_SNAKE_CASE      = tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]     )[0]
      self.assertEqual(__SCREAMING_SNAKE_CASE   ,				__SCREAMING_SNAKE_CASE     )

      __SCREAMING_SNAKE_CASE      = tokenizer.encode(__SCREAMING_SNAKE_CASE     )
      __SCREAMING_SNAKE_CASE      = encoded.index(__SCREAMING_SNAKE_CASE     )
      __SCREAMING_SNAKE_CASE      = tokenizer.convert_ids_to_tokens(encoded[mask_loc + 1]     )[0]
      self.assertNotEqual(__SCREAMING_SNAKE_CASE   ,				__SCREAMING_SNAKE_CASE     )
 def  UpperCAmelCase__						(						self   :			Dict     )    ->					Tuple:


      """simple docstring"""




      pass
 def  UpperCAmelCase__						(						self   :			int     )    ->					Any:


      """simple docstring"""




      for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
           with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'     ):
                __SCREAMING_SNAKE_CASE      = self.rust_tokenizer_class.from_pretrained(__SCREAMING_SNAKE_CASE   ,				**__SCREAMING_SNAKE_CASE     )
                __SCREAMING_SNAKE_CASE      = self.tokenizer_class.from_pretrained(__SCREAMING_SNAKE_CASE   ,				**__SCREAMING_SNAKE_CASE     )
                __SCREAMING_SNAKE_CASE      = """A, <mask> AllenNLP sentence."""
                __SCREAMING_SNAKE_CASE      = tokenizer_r.encode_plus(__SCREAMING_SNAKE_CASE   ,				add_special_tokens=__SCREAMING_SNAKE_CASE   ,				return_token_type_ids=__SCREAMING_SNAKE_CASE     )
                __SCREAMING_SNAKE_CASE      = tokenizer_p.encode_plus(__SCREAMING_SNAKE_CASE   ,				add_special_tokens=__SCREAMING_SNAKE_CASE   ,				return_token_type_ids=__SCREAMING_SNAKE_CASE     )

                # token_type_ids should put 0 everywhere
                self.assertEqual(sum(tokens_r["""token_type_ids"""]     )   ,				sum(tokens_p["""token_type_ids"""]     )     )

                # attention_mask should put 1 everywhere, so sum over length should be 1
                self.assertEqual(
                    sum(tokens_r["""attention_mask"""]     ) / len(tokens_r["""attention_mask"""]     )   ,				sum(tokens_p["""attention_mask"""]     ) / len(tokens_p["""attention_mask"""]     )   ,				)

                __SCREAMING_SNAKE_CASE      = tokenizer_r.convert_ids_to_tokens(tokens_r["""input_ids"""]     )
                __SCREAMING_SNAKE_CASE      = tokenizer_p.convert_ids_to_tokens(tokens_p["""input_ids"""]     )

                # Rust correctly handles the space before the mask while python doesnt
                self.assertSequenceEqual(tokens_p["""input_ids"""]   ,				[0, 250, 6, 50_264, 3_823, 487, 21_992, 3_645, 4, 2]     )
                self.assertSequenceEqual(tokens_r["""input_ids"""]   ,				[0, 250, 6, 50_264, 3_823, 487, 21_992, 3_645, 4, 2]     )

                self.assertSequenceEqual(
                    __SCREAMING_SNAKE_CASE   ,				["""<s>""", """A""", """,""", """<mask>""", """ĠAllen""", """N""", """LP""", """Ġsentence""", """.""", """</s>"""]     )
                self.assertSequenceEqual(
                    __SCREAMING_SNAKE_CASE   ,				["""<s>""", """A""", """,""", """<mask>""", """ĠAllen""", """N""", """LP""", """Ġsentence""", """.""", """</s>"""]     )
 def  UpperCAmelCase__						(						self   :			str     )    ->					str:


      """simple docstring"""




      for trim_offsets, add_prefix_space in itertools.product([True, False]   ,				repeat=2     ):
           __SCREAMING_SNAKE_CASE      = self.rust_tokenizer_class.from_pretrained(
               self.tmpdirname   ,				use_fast=__SCREAMING_SNAKE_CASE   ,				add_prefix_space=__SCREAMING_SNAKE_CASE   ,				trim_offsets=__SCREAMING_SNAKE_CASE     )

           __SCREAMING_SNAKE_CASE      = json.loads(tokenizer_r.backend_tokenizer.pre_tokenizer.__getstate__()     )
           __SCREAMING_SNAKE_CASE      = json.loads(tokenizer_r.backend_tokenizer.post_processor.__getstate__()     )

           self.assertEqual(pre_tokenizer_state["""add_prefix_space"""]   ,				__SCREAMING_SNAKE_CASE     )

           self.assertEqual(post_processor_state["""add_prefix_space"""]   ,				__SCREAMING_SNAKE_CASE     )
           self.assertEqual(post_processor_state["""trim_offsets"""]   ,				__SCREAMING_SNAKE_CASE     )


 def  UpperCAmelCase__						(						self   :			Any     )    ->					Any:


      """simple docstring"""




      for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
           with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'     ):
                __SCREAMING_SNAKE_CASE      = """hello"""  # `hello` is a token in the vocabulary of `pretrained_name`
                __SCREAMING_SNAKE_CASE      = f'{text_of_1_token} {text_of_1_token}'

                __SCREAMING_SNAKE_CASE      = self.rust_tokenizer_class.from_pretrained(
                    __SCREAMING_SNAKE_CASE   ,				use_fast=__SCREAMING_SNAKE_CASE   ,				add_prefix_space=__SCREAMING_SNAKE_CASE   ,				trim_offsets=__SCREAMING_SNAKE_CASE     )
                __SCREAMING_SNAKE_CASE      = tokenizer_r(__SCREAMING_SNAKE_CASE   ,				return_offsets_mapping=__SCREAMING_SNAKE_CASE   ,				add_special_tokens=__SCREAMING_SNAKE_CASE     )
                self.assertEqual(encoding.offset_mapping[0]   ,				(0, len(__SCREAMING_SNAKE_CASE     ))     )
                self.assertEqual(
                    encoding.offset_mapping[1]   ,				(len(__SCREAMING_SNAKE_CASE     ) + 1, len(__SCREAMING_SNAKE_CASE     ) + 1 + len(__SCREAMING_SNAKE_CASE     ))   ,				)

                __SCREAMING_SNAKE_CASE      = self.rust_tokenizer_class.from_pretrained(
                    __SCREAMING_SNAKE_CASE   ,				use_fast=__SCREAMING_SNAKE_CASE   ,				add_prefix_space=__SCREAMING_SNAKE_CASE   ,				trim_offsets=__SCREAMING_SNAKE_CASE     )
                __SCREAMING_SNAKE_CASE      = tokenizer_r(__SCREAMING_SNAKE_CASE   ,				return_offsets_mapping=__SCREAMING_SNAKE_CASE   ,				add_special_tokens=__SCREAMING_SNAKE_CASE     )
                self.assertEqual(encoding.offset_mapping[0]   ,				(0, len(__SCREAMING_SNAKE_CASE     ))     )
                self.assertEqual(
                    encoding.offset_mapping[1]   ,				(len(__SCREAMING_SNAKE_CASE     ) + 1, len(__SCREAMING_SNAKE_CASE     ) + 1 + len(__SCREAMING_SNAKE_CASE     ))   ,				)

                __SCREAMING_SNAKE_CASE      = self.rust_tokenizer_class.from_pretrained(
                    __SCREAMING_SNAKE_CASE   ,				use_fast=__SCREAMING_SNAKE_CASE   ,				add_prefix_space=__SCREAMING_SNAKE_CASE   ,				trim_offsets=__SCREAMING_SNAKE_CASE     )
                __SCREAMING_SNAKE_CASE      = tokenizer_r(__SCREAMING_SNAKE_CASE   ,				return_offsets_mapping=__SCREAMING_SNAKE_CASE   ,				add_special_tokens=__SCREAMING_SNAKE_CASE     )
                self.assertEqual(encoding.offset_mapping[0]   ,				(0, len(__SCREAMING_SNAKE_CASE     ))     )
                self.assertEqual(
                    encoding.offset_mapping[1]   ,				(len(__SCREAMING_SNAKE_CASE     ), len(__SCREAMING_SNAKE_CASE     ) + 1 + len(__SCREAMING_SNAKE_CASE     ))   ,				)

                __SCREAMING_SNAKE_CASE      = self.rust_tokenizer_class.from_pretrained(
                    __SCREAMING_SNAKE_CASE   ,				use_fast=__SCREAMING_SNAKE_CASE   ,				add_prefix_space=__SCREAMING_SNAKE_CASE   ,				trim_offsets=__SCREAMING_SNAKE_CASE     )
                __SCREAMING_SNAKE_CASE      = tokenizer_r(__SCREAMING_SNAKE_CASE   ,				return_offsets_mapping=__SCREAMING_SNAKE_CASE   ,				add_special_tokens=__SCREAMING_SNAKE_CASE     )
                self.assertEqual(encoding.offset_mapping[0]   ,				(0, len(__SCREAMING_SNAKE_CASE     ))     )
                self.assertEqual(
                    encoding.offset_mapping[1]   ,				(len(__SCREAMING_SNAKE_CASE     ), len(__SCREAMING_SNAKE_CASE     ) + 1 + len(__SCREAMING_SNAKE_CASE     ))   ,				)

                __SCREAMING_SNAKE_CASE      = f' {text}'

                # tokenizer_r = self.rust_tokenizer_class.from_pretrained(
                #     pretrained_name, use_fast=True, add_prefix_space=True, trim_offsets=True
                # )
                # encoding = tokenizer_r(text, return_offsets_mapping=True, add_special_tokens=False)
                # self.assertEqual(encoding.offset_mapping[0], (1, 1 + len(text_of_1_token)))
                # self.assertEqual(
                #     encoding.offset_mapping[1],
                #     (1 + len(text_of_1_token) + 1, 1 + len(text_of_1_token) + 1 + len(text_of_1_token)),
                # )

                __SCREAMING_SNAKE_CASE      = self.rust_tokenizer_class.from_pretrained(
                    __SCREAMING_SNAKE_CASE   ,				use_fast=__SCREAMING_SNAKE_CASE   ,				add_prefix_space=__SCREAMING_SNAKE_CASE   ,				trim_offsets=__SCREAMING_SNAKE_CASE     )
                __SCREAMING_SNAKE_CASE      = tokenizer_r(__SCREAMING_SNAKE_CASE   ,				return_offsets_mapping=__SCREAMING_SNAKE_CASE   ,				add_special_tokens=__SCREAMING_SNAKE_CASE     )
                self.assertEqual(encoding.offset_mapping[0]   ,				(1, 1 + len(__SCREAMING_SNAKE_CASE     ))     )
                self.assertEqual(
                    encoding.offset_mapping[1]   ,				(1 + len(__SCREAMING_SNAKE_CASE     ) + 1, 1 + len(__SCREAMING_SNAKE_CASE     ) + 1 + len(__SCREAMING_SNAKE_CASE     ))   ,				)

                __SCREAMING_SNAKE_CASE      = self.rust_tokenizer_class.from_pretrained(
                    __SCREAMING_SNAKE_CASE   ,				use_fast=__SCREAMING_SNAKE_CASE   ,				add_prefix_space=__SCREAMING_SNAKE_CASE   ,				trim_offsets=__SCREAMING_SNAKE_CASE     )
                __SCREAMING_SNAKE_CASE      = tokenizer_r(__SCREAMING_SNAKE_CASE   ,				return_offsets_mapping=__SCREAMING_SNAKE_CASE   ,				add_special_tokens=__SCREAMING_SNAKE_CASE     )
                self.assertEqual(encoding.offset_mapping[0]   ,				(0, 1 + len(__SCREAMING_SNAKE_CASE     ))     )
                self.assertEqual(
                    encoding.offset_mapping[1]   ,				(1 + len(__SCREAMING_SNAKE_CASE     ), 1 + len(__SCREAMING_SNAKE_CASE     ) + 1 + len(__SCREAMING_SNAKE_CASE     ))   ,				)

                __SCREAMING_SNAKE_CASE      = self.rust_tokenizer_class.from_pretrained(
                    __SCREAMING_SNAKE_CASE   ,				use_fast=__SCREAMING_SNAKE_CASE   ,				add_prefix_space=__SCREAMING_SNAKE_CASE   ,				trim_offsets=__SCREAMING_SNAKE_CASE     )
                __SCREAMING_SNAKE_CASE      = tokenizer_r(__SCREAMING_SNAKE_CASE   ,				return_offsets_mapping=__SCREAMING_SNAKE_CASE   ,				add_special_tokens=__SCREAMING_SNAKE_CASE     )
                self.assertEqual(encoding.offset_mapping[0]   ,				(0, 1 + len(__SCREAMING_SNAKE_CASE     ))     )
                self.assertEqual(
                    encoding.offset_mapping[1]   ,				(1 + len(__SCREAMING_SNAKE_CASE     ), 1 + len(__SCREAMING_SNAKE_CASE     ) + 1 + len(__SCREAMING_SNAKE_CASE     ))   ,				)









'''simple docstring'''



from typing import Optional, Union

import torch
from torch import nn

from ...configuration_utils import ConfigMixin, register_to_config
from ...models.modeling_utils import ModelMixin







class 		lowerCAmelCase__  ( a					,   a   ):



 """simple docstring"""



 @register_to_config
 def __init__(						self   :			int   ,				__SCREAMING_SNAKE_CASE   :			int = 768   ,				)    ->					int:


      """simple docstring"""




      super().__init__()

      __SCREAMING_SNAKE_CASE      = nn.Parameter(torch.zeros(1   ,				__SCREAMING_SNAKE_CASE     )     )
      __SCREAMING_SNAKE_CASE      = nn.Parameter(torch.ones(1   ,				__SCREAMING_SNAKE_CASE     )     )
 def  UpperCAmelCase__						(						self   :			Any   ,				__SCREAMING_SNAKE_CASE   :			Optional[Union[str, torch.device]] = None   ,				__SCREAMING_SNAKE_CASE   :			Optional[torch.dtype] = None   ,				)    ->					List[str]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = nn.Parameter(self.mean.to(__SCREAMING_SNAKE_CASE     ).to(__SCREAMING_SNAKE_CASE     )     )
      __SCREAMING_SNAKE_CASE      = nn.Parameter(self.std.to(__SCREAMING_SNAKE_CASE     ).to(__SCREAMING_SNAKE_CASE     )     )
      return self
 def  UpperCAmelCase__						(						self   :			Optional[Any]   ,				__SCREAMING_SNAKE_CASE   :			Optional[int]     )    ->					Optional[int]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = (embeds - self.mean) * 1.0 / self.std
      return embeds


 def  UpperCAmelCase__						(						self   :			Tuple   ,				__SCREAMING_SNAKE_CASE   :			Any     )    ->					Optional[int]:


      """simple docstring"""




      __SCREAMING_SNAKE_CASE      = (embeds * self.std) + self.mean
      return embeds






