




'''simple docstring'''







import random
import unittest

from torch.utils.data import BatchSampler, DataLoader, IterableDataset

from accelerate import Accelerator
from accelerate.data_loader import (
    BatchSamplerShard,
    DataLoaderDispatcher,
    DataLoaderShard,
    IterableDatasetShard,
    SkipBatchSampler,
    SkipDataLoader,
    skip_first_batches,
)


class 			_a  (	__a ):
       def __init__(	self						:	int   ,				lowercase						:	Union[str, Any]=0.01   ,				lowercase						:	Tuple=1_000				):



           '''simple docstring'''

           UpperCAmelCase			       =		p_stop
           UpperCAmelCase			       =		max_length







       def __iter__(	self						:	Any				):



           '''simple docstring'''

           UpperCAmelCase			       =		0
           UpperCAmelCase			       =		False
           while not stop and count < self.max_length:
               yield count
               count += 1
               UpperCAmelCase			       =		random.random() < self.p_stop






class 			_a  (	unittest.TestCase ):
       def     A      (	self						:	Optional[Any]   ,				lowercase						:	Any   ,				lowercase						:	Union[str, Any]   ,				lowercase						:	Optional[int]=False   ,				lowercase						:	Any=True				):



           '''simple docstring'''

           UpperCAmelCase			       =		[
               BatchSamplerShard(lowercase   ,				2   ,				lowercase   ,				split_batches=lowercase   ,				even_batches=lowercase				)
               for i in range(2				)
           ]
           UpperCAmelCase			       =		[list(lowercase				) for batch_sampler_shard in batch_sampler_shards]
           if not split_batches:
               self.assertListEqual([len(lowercase				) for shard in batch_sampler_shards]   ,				[len(lowercase				) for e in expected]				)
           self.assertListEqual(lowercase   ,				lowercase				)
       def     A      (	self						:	Optional[int]				):



           '''simple docstring'''

           UpperCAmelCase			       =		BatchSampler(range(24				)   ,				batch_size=3   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21, 22, 23]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase				)

           UpperCAmelCase			       =		BatchSampler(range(24				)   ,				batch_size=3   ,				drop_last=lowercase				)
           # Expected shouldn't change
           self.check_batch_sampler_shards(lowercase   ,				lowercase				)

           # Check the shards when the dataset is a round multiple of batch size but not total batch size.
           UpperCAmelCase			       =		BatchSampler(range(21				)   ,				batch_size=3   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17], [0, 1, 2]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase				)

           UpperCAmelCase			       =		BatchSampler(range(21				)   ,				batch_size=3   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase				)

           # Check the shards when the dataset is not a round multiple of batch size but has a multiple of
           # num_processes batch.
           UpperCAmelCase			       =		BatchSampler(range(22				)   ,				batch_size=3   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21, 0, 1]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase				)

           UpperCAmelCase			       =		BatchSampler(range(22				)   ,				batch_size=3   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase				)

           # Check the shards when the dataset is not a round multiple of batch size but and has not a multiple of
           # num_processes batch.
           UpperCAmelCase			       =		BatchSampler(range(20				)   ,				batch_size=3   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 0]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17], [1, 2, 3]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase				)

           UpperCAmelCase			       =		BatchSampler(range(20				)   ,				batch_size=3   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase				)

           # Check the shards when the dataset is very small.
           UpperCAmelCase			       =		BatchSampler(range(2				)   ,				batch_size=3   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[[[0, 1, 0]], [[1, 0, 1]]]
           self.check_batch_sampler_shards(lowercase   ,				lowercase				)

           UpperCAmelCase			       =		BatchSampler(range(2				)   ,				batch_size=3   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[[], []]
           self.check_batch_sampler_shards(lowercase   ,				lowercase				)
       def     A      (	self						:	Optional[Any]				):



           '''simple docstring'''

           UpperCAmelCase			       =		BatchSampler(range(24				)   ,				batch_size=4   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]],
               [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [22, 23]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				split_batches=lowercase				)

           UpperCAmelCase			       =		BatchSampler(range(24				)   ,				batch_size=4   ,				drop_last=lowercase				)
           # Expected shouldn't change
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				split_batches=lowercase				)

           # Check the shards when the dataset is not a round multiple of batch size.
           UpperCAmelCase			       =		BatchSampler(range(22				)   ,				batch_size=4   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]],
               [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [0, 1]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				split_batches=lowercase				)

           UpperCAmelCase			       =		BatchSampler(range(22				)   ,				batch_size=4   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]],
               [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				split_batches=lowercase				)

           # Check the shards when the dataset is not a round multiple of batch size or num_processes.
           UpperCAmelCase			       =		BatchSampler(range(21				)   ,				batch_size=4   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 0]],
               [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [1, 2]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				split_batches=lowercase				)

           UpperCAmelCase			       =		BatchSampler(range(21				)   ,				batch_size=4   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]],
               [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				split_batches=lowercase				)

           # Check the shards when the dataset is very small.
           UpperCAmelCase			       =		BatchSampler(range(2				)   ,				batch_size=4   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[[[0, 1]], [[0, 1]]]
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				split_batches=lowercase				)

           UpperCAmelCase			       =		BatchSampler(range(2				)   ,				batch_size=4   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[[], []]
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				split_batches=lowercase				)
       def     A      (	self						:	Optional[Any]				):



           '''simple docstring'''

           UpperCAmelCase			       =		BatchSampler(range(24				)   ,				batch_size=3   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21, 22, 23]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				even_batches=lowercase				)

           UpperCAmelCase			       =		BatchSampler(range(24				)   ,				batch_size=3   ,				drop_last=lowercase				)
           # Expected shouldn't change
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				even_batches=lowercase				)

           # Check the shards when the dataset is a round multiple of batch size but not total batch size.
           UpperCAmelCase			       =		BatchSampler(range(21				)   ,				batch_size=3   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				even_batches=lowercase				)

           UpperCAmelCase			       =		BatchSampler(range(21				)   ,				batch_size=3   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				even_batches=lowercase				)

           # Check the shards when the dataset is not a round multiple of batch size but has a multiple of
           # num_processes batch.
           UpperCAmelCase			       =		BatchSampler(range(22				)   ,				batch_size=3   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				even_batches=lowercase				)

           UpperCAmelCase			       =		BatchSampler(range(22				)   ,				batch_size=3   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				even_batches=lowercase				)

           # Check the shards when the dataset is not a round multiple of batch size but and has not a multiple of
           # num_processes batch.
           UpperCAmelCase			       =		BatchSampler(range(20				)   ,				batch_size=3   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				even_batches=lowercase				)

           UpperCAmelCase			       =		BatchSampler(range(20				)   ,				batch_size=3   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				even_batches=lowercase				)

           # Check the shards when the dataset is very small.
           UpperCAmelCase			       =		BatchSampler(range(2				)   ,				batch_size=3   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[[[0, 1]], []]
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				even_batches=lowercase				)

           UpperCAmelCase			       =		BatchSampler(range(2				)   ,				batch_size=3   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[[], []]
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				even_batches=lowercase				)
       def     A      (	self						:	int				):



           '''simple docstring'''

           UpperCAmelCase			       =		BatchSampler(range(24				)   ,				batch_size=4   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]],
               [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [22, 23]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				split_batches=lowercase   ,				even_batches=lowercase				)

           UpperCAmelCase			       =		BatchSampler(range(24				)   ,				batch_size=4   ,				drop_last=lowercase				)
           # Expected shouldn't change
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				split_batches=lowercase   ,				even_batches=lowercase				)

           # Check the shards when the dataset is not a round multiple of batch size.
           UpperCAmelCase			       =		BatchSampler(range(22				)   ,				batch_size=4   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]],
               [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				split_batches=lowercase   ,				even_batches=lowercase				)

           UpperCAmelCase			       =		BatchSampler(range(22				)   ,				batch_size=4   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]],
               [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				split_batches=lowercase   ,				even_batches=lowercase				)

           # Check the shards when the dataset is not a round multiple of batch size or num_processes.
           UpperCAmelCase			       =		BatchSampler(range(21				)   ,				batch_size=4   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20]],
               [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				split_batches=lowercase   ,				even_batches=lowercase				)

           UpperCAmelCase			       =		BatchSampler(range(21				)   ,				batch_size=4   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[
               [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]],
               [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
           ]
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				split_batches=lowercase   ,				even_batches=lowercase				)

           # Check the shards when the dataset is very small.
           UpperCAmelCase			       =		BatchSampler(range(2				)   ,				batch_size=4   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[[[0, 1]], []]
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				split_batches=lowercase   ,				even_batches=lowercase				)

           UpperCAmelCase			       =		BatchSampler(range(2				)   ,				batch_size=4   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		[[], []]
           self.check_batch_sampler_shards(lowercase   ,				lowercase   ,				split_batches=lowercase   ,				even_batches=lowercase				)
       def     A      (	self						:	Any				):



           '''simple docstring'''

           UpperCAmelCase			       =		[[0, 1, 2], [3, 4], [5, 6, 7, 8], [9, 10, 11], [12, 13]]
           UpperCAmelCase			       =		[BatchSamplerShard(lowercase   ,				2   ,				lowercase   ,				even_batches=lowercase				) for i in range(2				)]

           self.assertEqual(len(batch_sampler_shards[0]				)   ,				3				)
           self.assertEqual(len(batch_sampler_shards[1]				)   ,				2				)

           self.assertListEqual(list(batch_sampler_shards[0]				)   ,				[[0, 1, 2], [5, 6, 7, 8], [12, 13]]				)
           self.assertListEqual(list(batch_sampler_shards[1]				)   ,				[[3, 4], [9, 10, 11]]				)
       def     A      (	self						:	List[str]   ,				lowercase						:	Tuple   ,				lowercase						:	Optional[int]   ,				lowercase						:	int   ,				lowercase						:	Dict=False   ,				lowercase						:	str=2   ,				lowercase						:	Union[str, Any]=False				):



           '''simple docstring'''

           random.seed(lowercase				)
           UpperCAmelCase			       =		list(lowercase				)

           UpperCAmelCase			       =		[
               IterableDatasetShard(
                   lowercase   ,				batch_size=lowercase   ,				drop_last=lowercase   ,				num_processes=lowercase   ,				process_index=lowercase   ,				split_batches=lowercase   ,				)
               for i in range(lowercase				)
           ]
           UpperCAmelCase			       =		[]
           for iterable_dataset_shard in iterable_dataset_shards:
               # Since our random iterable dataset will be... random... we need to use a seed to get reproducible results.
               random.seed(lowercase				)
               iterable_dataset_lists.append(list(lowercase				)				)

           UpperCAmelCase			       =		batch_size // num_processes if split_batches else batch_size
           # All iterable dataset shard should have the same length, a round multiple of shard_batch_size
           UpperCAmelCase			       =		iterable_dataset_lists[0]
           for l in iterable_dataset_lists[1:]:
               self.assertEqual(len(lowercase				)   ,				len(lowercase				)				)
               self.assertTrue(len(lowercase				) % shard_batch_size == 0				)

           UpperCAmelCase			       =		[]
           for idx in range(0   ,				len(lowercase				)   ,				lowercase				):
               for l in iterable_dataset_lists:
                   observed += l[idx : idx + shard_batch_size]

           if not drop_last:
               while len(lowercase				) < len(lowercase				):
                   reference += reference
           self.assertListEqual(lowercase   ,				reference[: len(lowercase				)]				)
       def     A      (	self						:	int				):



           '''simple docstring'''

           UpperCAmelCase			       =		42
           UpperCAmelCase			       =		RandomIterableDataset()

           self.check_iterable_dataset_shards(lowercase   ,				lowercase   ,				batch_size=4   ,				drop_last=lowercase   ,				split_batches=lowercase				)
           self.check_iterable_dataset_shards(lowercase   ,				lowercase   ,				batch_size=4   ,				drop_last=lowercase   ,				split_batches=lowercase				)
           self.check_iterable_dataset_shards(lowercase   ,				lowercase   ,				batch_size=4   ,				drop_last=lowercase   ,				split_batches=lowercase				)
           self.check_iterable_dataset_shards(lowercase   ,				lowercase   ,				batch_size=4   ,				drop_last=lowercase   ,				split_batches=lowercase				)

           # Edge case with a very small dataset
           UpperCAmelCase			       =		RandomIterableDataset(max_length=2				)

           self.check_iterable_dataset_shards(lowercase   ,				lowercase   ,				batch_size=4   ,				drop_last=lowercase   ,				split_batches=lowercase				)
           self.check_iterable_dataset_shards(lowercase   ,				lowercase   ,				batch_size=4   ,				drop_last=lowercase   ,				split_batches=lowercase				)
           self.check_iterable_dataset_shards(lowercase   ,				lowercase   ,				batch_size=4   ,				drop_last=lowercase   ,				split_batches=lowercase				)
           self.check_iterable_dataset_shards(lowercase   ,				lowercase   ,				batch_size=4   ,				drop_last=lowercase   ,				split_batches=lowercase				)
       def     A      (	self						:	str				):



           '''simple docstring'''

           UpperCAmelCase			       =		BatchSampler(range(16				)   ,				batch_size=4   ,				drop_last=lowercase				)
           UpperCAmelCase			       =		SkipBatchSampler(lowercase   ,				2				)
           self.assertListEqual(list(lowercase				)   ,				[[8, 9, 10, 11], [12, 13, 14, 15]]				)
       def     A      (	self						:	Optional[Any]				):



           '''simple docstring'''

           UpperCAmelCase			       =		SkipDataLoader(list(range(16				)				)   ,				batch_size=4   ,				skip_batches=2				)
           self.assertListEqual([t.tolist() for t in dataloader]   ,				[[8, 9, 10, 11], [12, 13, 14, 15]]				)
       def     A      (	self						:	List[Any]				):



           '''simple docstring'''

           UpperCAmelCase			       =		DataLoader(list(range(16				)				)   ,				batch_size=4				)
           UpperCAmelCase			       =		skip_first_batches(lowercase   ,				num_batches=2				)
           self.assertListEqual([t.tolist() for t in new_dataloader]   ,				[[8, 9, 10, 11], [12, 13, 14, 15]]				)
       def     A      (	self						:	Optional[Any]				):



           '''simple docstring'''

           UpperCAmelCase			       =		DataLoaderShard(list(range(16				)				)   ,				batch_size=4				)
           for idx, _ in enumerate(lowercase				):
               self.assertEqual(dataloader.end_of_dataloader   ,				idx == 3				)

           # Test it also works on the second iteration
           for idx, _ in enumerate(lowercase				):
               self.assertEqual(dataloader.end_of_dataloader   ,				idx == 3				)







       def     A      (	self						:	int				):



           '''simple docstring'''

           Accelerator()
           UpperCAmelCase			       =		DataLoaderDispatcher(range(16				)   ,				batch_size=4				)
           for idx, _ in enumerate(lowercase				):
               self.assertEqual(dataloader.end_of_dataloader   ,				idx == 3				)

           # Test it also works on the second iteration
           for idx, _ in enumerate(lowercase				):
               self.assertEqual(dataloader.end_of_dataloader   ,				idx == 3				)







'''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 							A__    (       A__     ,   A__  ):





  @register_to_config
  def __init__(		self      :	Dict							,					_a      :	int = 768							,					)	->    Union[str, Any]:





       '''simple docstring'''






       super().__init__()

       _SCREAMING_SNAKE_CASE							    =nn.Parameter(torch.zeros(1							,					_a ) )
       _SCREAMING_SNAKE_CASE							    =nn.Parameter(torch.ones(1							,					_a ) )





  def 						A  (		self      :	Tuple							,					_a      :	Optional[Union[str, torch.device]] = None							,					_a      :	Optional[torch.dtype] = None							,					)	->    List[Any]:





       '''simple docstring'''






       _SCREAMING_SNAKE_CASE							    =nn.Parameter(self.mean.to(_a ).to(_a ) )
       _SCREAMING_SNAKE_CASE							    =nn.Parameter(self.std.to(_a ).to(_a ) )
       return self





  def 						A  (		self      :	Tuple							,					_a      :	str )	->    str:





       '''simple docstring'''






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





  def 						A  (		self      :	List[str]							,					_a      :	Optional[Any] )	->    Tuple:





       '''simple docstring'''






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