import unittest

from transformers import SPIECE_UNDERLINE, ReformerTokenizer, ReformerTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


UpperCAmelCase_			    =							get_tests_dir('''fixtures/test_sentencepiece.model''')




@require_sentencepiece
@require_tokenizers
class  __magic_name__  (		__a      ,	unittest.TestCase    ):





   """simple docstring"""




   lowerCAmelCase      :    Any  			=   ReformerTokenizer
   lowerCAmelCase      :    Optional[Any]  			=   ReformerTokenizerFast
   lowerCAmelCase      :    List[str]  			=   True
   lowerCAmelCase      :    int  			=   False
   lowerCAmelCase      :    List[Any]  			=   True



   def   lowerCAmelCase						(	self					:  Any							):



    """simple docstring"""



    super().setUp()

    _UpperCamelCase:     Dict							= ReformerTokenizer(_lowercase		,  keep_accents=_lowercase							)
    tokenizer.save_pretrained(self.tmpdirname							)



   def   lowerCAmelCase						(	self					:  Optional[Any]							):



    """simple docstring"""



    _UpperCamelCase:     List[Any]							= '''<s>'''
    _UpperCamelCase:     Tuple							= 1

    self.assertEqual(self.get_tokenizer()._convert_token_to_id(_lowercase							)		,  _lowercase							)
    self.assertEqual(self.get_tokenizer()._convert_id_to_token(_lowercase							)		,  _lowercase							)



   def   lowerCAmelCase						(	self					:  List[str]							):



    """simple docstring"""



    _UpperCamelCase:     Any							= list(self.get_tokenizer().get_vocab().keys()							)

    self.assertEqual(vocab_keys[0]		,  '''<unk>'''							)
    self.assertEqual(vocab_keys[1]		,  '''<s>'''							)
    self.assertEqual(vocab_keys[-1]		,  '''j'''							)
    self.assertEqual(len(_lowercase							)		,  1_000							)



   def   lowerCAmelCase						(	self					:  List[str]							):



    """simple docstring"""



    self.assertEqual(self.get_tokenizer().vocab_size		,  1_000							)



   def   lowerCAmelCase						(	self					:  int							):



    """simple docstring"""



    if not self.test_rust_tokenizer:
     return

    _UpperCamelCase:     Any							= self.get_tokenizer()
    _UpperCamelCase:     str							= self.get_rust_tokenizer()

    _UpperCamelCase:     List[Any]							= '''I was born in 92000, and this is falsé.'''

    _UpperCamelCase:     Dict							= tokenizer.tokenize(_lowercase							)
    _UpperCamelCase:     Optional[int]							= rust_tokenizer.tokenize(_lowercase							)
    self.assertListEqual(_lowercase		,  _lowercase							)

    _UpperCamelCase:     Tuple							= tokenizer.encode(_lowercase		,  add_special_tokens=_lowercase							)
    _UpperCamelCase:     Tuple							= rust_tokenizer.encode(_lowercase		,  add_special_tokens=_lowercase							)
    self.assertListEqual(_lowercase		,  _lowercase							)

    _UpperCamelCase:     Tuple							= self.get_rust_tokenizer()
    _UpperCamelCase:     Tuple							= tokenizer.encode(_lowercase							)
    _UpperCamelCase:     List[Any]							= rust_tokenizer.encode(_lowercase							)
    self.assertListEqual(_lowercase		,  _lowercase							)



   def   lowerCAmelCase						(	self					:  List[Any]		,  _lowercase					:  List[Any]=15							):



    """simple docstring"""



    for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
     with self.subTest(f"""{tokenizer.__class__.__name__} ({pretrained_name})"""							):
      _UpperCamelCase:     Dict							= self.rust_tokenizer_class.from_pretrained(_lowercase		,  **_lowercase							)

      # Simple input
      _UpperCamelCase:     Tuple							= '''This is a simple input'''
      _UpperCamelCase:     Dict							= ['''This is a simple input 1''', '''This is a simple input 2''']
      _UpperCamelCase:     Any							= ('''This is a simple input''', '''This is a pair''')
      _UpperCamelCase:     List[Any]							= [
          ('''This is a simple input 1''', '''This is a simple input 2'''),
          ('''This is a simple pair 1''', '''This is a simple pair 2'''),
      ]

      # Simple input tests
      self.assertRaises(_lowercase		,  tokenizer_r.encode		,  _lowercase		,  max_length=_lowercase		,  padding='''max_length'''							)

      # Simple input
      self.assertRaises(_lowercase		,  tokenizer_r.encode_plus		,  _lowercase		,  max_length=_lowercase		,  padding='''max_length'''							)

      # Simple input
      self.assertRaises(
          _lowercase		,  tokenizer_r.batch_encode_plus		,  _lowercase		,  max_length=_lowercase		,  padding='''max_length'''		,  )

      # Pair input
      self.assertRaises(_lowercase		,  tokenizer_r.encode		,  _lowercase		,  max_length=_lowercase		,  padding='''max_length'''							)

      # Pair input
      self.assertRaises(_lowercase		,  tokenizer_r.encode_plus		,  _lowercase		,  max_length=_lowercase		,  padding='''max_length'''							)

      # Pair input
      self.assertRaises(
          _lowercase		,  tokenizer_r.batch_encode_plus		,  _lowercase		,  max_length=_lowercase		,  padding='''max_length'''		,  )



   def   lowerCAmelCase						(	self					:  int							):



    """simple docstring"""



    pass



   def   lowerCAmelCase						(	self					:  Dict							):



    """simple docstring"""



    _UpperCamelCase:     Dict							= ReformerTokenizer(_lowercase		,  keep_accents=_lowercase							)

    _UpperCamelCase:     List[str]							= tokenizer.tokenize('''This is a test'''							)
    self.assertListEqual(_lowercase		,  ['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']							)

    self.assertListEqual(
        tokenizer.convert_tokens_to_ids(_lowercase							)		,  [285, 46, 10, 170, 382]		,  )

    _UpperCamelCase:     Optional[int]							= tokenizer.tokenize('''I was born in 92000, and this is falsé.'''							)
    self.assertListEqual(
        _lowercase		,  [
            SPIECE_UNDERLINE + '''I''',
            SPIECE_UNDERLINE + '''was''',
            SPIECE_UNDERLINE + '''b''',
            '''or''',
            '''n''',
            SPIECE_UNDERLINE + '''in''',
            SPIECE_UNDERLINE + '''''',
            '''9''',
            '''2''',
            '''0''',
            '''0''',
            '''0''',
            ''',''',
            SPIECE_UNDERLINE + '''and''',
            SPIECE_UNDERLINE + '''this''',
            SPIECE_UNDERLINE + '''is''',
            SPIECE_UNDERLINE + '''f''',
            '''al''',
            '''s''',
            '''é''',
            '''.''',
        ]		,  )
    _UpperCamelCase:     str							= tokenizer.convert_tokens_to_ids(_lowercase							)
    self.assertListEqual(
        _lowercase		,  [8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4]		,  )

    _UpperCamelCase:     List[str]							= tokenizer.convert_ids_to_tokens(_lowercase							)
    self.assertListEqual(
        _lowercase		,  [
            SPIECE_UNDERLINE + '''I''',
            SPIECE_UNDERLINE + '''was''',
            SPIECE_UNDERLINE + '''b''',
            '''or''',
            '''n''',
            SPIECE_UNDERLINE + '''in''',
            SPIECE_UNDERLINE + '''''',
            '''<unk>''',
            '''2''',
            '''0''',
            '''0''',
            '''0''',
            ''',''',
            SPIECE_UNDERLINE + '''and''',
            SPIECE_UNDERLINE + '''this''',
            SPIECE_UNDERLINE + '''is''',
            SPIECE_UNDERLINE + '''f''',
            '''al''',
            '''s''',
            '''<unk>''',
            '''.''',
        ]		,  )



   @cached_property
   def   lowerCAmelCase						(	self					:  List[str]							):



    """simple docstring"""



    return ReformerTokenizer.from_pretrained('''google/reformer-crime-and-punishment'''							)



   @slow
   def   lowerCAmelCase						(	self					:  Optional[int]							):



    """simple docstring"""



    _UpperCamelCase:     Tuple							= '''Hello World!'''
    _UpperCamelCase:     Tuple							= [126, 32, 262, 152, 38, 72, 287]

    self.assertListEqual(_lowercase		,  self.big_tokenizer.encode(_lowercase							)							)



   @slow
   def   lowerCAmelCase						(	self					:  Optional[Any]							):



    """simple docstring"""



    _UpperCamelCase:     List[str]							= (
        '''This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) " [ ] ! : - . Also we will'''
        ''' add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth'''
    )
    _UpperCamelCase:     List[Any]							= [
        108,
        265,
        24,
        111,
        4,
        258,
        156,
        35,
        28,
        275,
        3,
        259,
        297,
        260,
        84,
        4,
        35,
        110,
        44,
        8,
        259,
        91,
        268,
        21,
        11,
        209,
        274,
        109,
        266,
        277,
        117,
        86,
        93,
        315,
        258,
        278,
        258,
        277,
        258,
        0,
        258,
        288,
        258,
        319,
        258,
        0,
        258,
        0,
        258,
        0,
        258,
        0,
        258,
        287,
        258,
        315,
        258,
        289,
        258,
        278,
        99,
        269,
        266,
        262,
        8,
        259,
        241,
        4,
        217,
        230,
        268,
        266,
        55,
        168,
        106,
        75,
        193,
        266,
        223,
        27,
        49,
        26,
        282,
        25,
        264,
        299,
        19,
        26,
        0,
        258,
        277,
        117,
        86,
        93,
        176,
        183,
        270,
        11,
        262,
        42,
        61,
        265,
    ]

    self.assertListEqual(_lowercase		,  self.big_tokenizer.encode(_lowercase							)							)



   @require_torch
   @slow
   def   lowerCAmelCase						(	self					:  Optional[Any]							):



    """simple docstring"""



    import torch

    from transformers import ReformerConfig, ReformerModel

    # Build sequence
    _UpperCamelCase:     List[str]							= list(self.big_tokenizer.get_vocab().keys()							)[:10]
    _UpperCamelCase:     Union[str, Any]							= ''' '''.join(_lowercase							)
    _UpperCamelCase:     List[str]							= self.big_tokenizer.encode_plus(_lowercase		,  return_tensors='''pt'''							)
    _UpperCamelCase:     Optional[int]							= self.big_tokenizer.batch_encode_plus([sequence, sequence]		,  return_tensors='''pt'''							)

    _UpperCamelCase:     List[str]							= ReformerConfig()
    # The input gets padded during training so adjust the axial position encodings from the pretrained model value of (512, 1024)
    _UpperCamelCase:     int							= encoded_sequence['''input_ids'''].shape
    _UpperCamelCase:     List[str]							= ReformerModel(_lowercase							)

    # Reformer has config.vocab_size == tokenizer.vocab_size == len(tokenizer) - 1 = 320; len(tokenizer) is 321 (including a pad token with id 320)
    assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size

    with torch.no_grad():
     model(**_lowercase							)
     model(**_lowercase							)



   @slow
   def   lowerCAmelCase						(	self					:  List[Any]							):



    """simple docstring"""



    _UpperCamelCase:     Any							= {'''input_ids''': [[108, 265, 24, 111, 4, 258, 156, 7, 51, 279, 58, 7, 76, 25, 69, 278], [140, 243, 264, 134, 17, 267, 77, 263, 22, 262, 297, 258, 304, 177, 279, 266, 14, 89, 13, 35, 261, 299, 272, 137, 275, 278]], '''attention_mask''': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}  # noqa: E501
    # fmt: on

    # This tokenizer does not know some characters like ")".
    # That is the reason why we use very simple texts here.
    # Also see https://github.com/huggingface/transformers/pull/11737#issuecomment-850769064
    _UpperCamelCase:     str							= [
        '''This is a very simple sentence.''',
        '''The quick brown fox jumps over the lazy dog.''',
    ]

    self.tokenizer_integration_test_util(
        expected_encoding=_lowercase		,  model_name='''google/reformer-crime-and-punishment'''		,  revision='''0e6c3decb8211d49bf881013425dc8b0448b3f5a'''		,  padding=_lowercase		,  sequences=_lowercase		,  )
import gc
import random
import unittest

import numpy as np
import torch
from PIL import Image
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, PNDMScheduler, StableDiffusionInpaintPipeline, UNetaDConditionModel
from diffusers.utils import floats_tensor, load_image, load_numpy, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, slow

from ..pipeline_params import TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS, TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()




class  __magic_name__  (		__a      ,	__a      ,	__a      ,	unittest.TestCase    ):





   """simple docstring"""




   lowerCAmelCase      :    Optional[int]  			=   StableDiffusionInpaintPipeline
   lowerCAmelCase      :    Optional[Any]  			=   TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
   lowerCAmelCase      :    str  			=   TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
   lowerCAmelCase      :    str  			=   frozenset(
       []    )  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
   lowerCAmelCase      :    Tuple  			=   frozenset([]    )



   def   lowerCAmelCase						(	self					:  Dict							):



    """simple docstring"""



    torch.manual_seed(0							)
    _UpperCamelCase:     List[str]							= UNetaDConditionModel(
        block_out_channels=(32, 64)		,  layers_per_block=2		,  sample_size=32		,  in_channels=9		,  out_channels=4		,  down_block_types=('''DownBlock2D''', '''CrossAttnDownBlock2D''')		,  up_block_types=('''CrossAttnUpBlock2D''', '''UpBlock2D''')		,  cross_attention_dim=32		,  attention_head_dim=(2, 4)		,  use_linear_projection=_lowercase		,  )
    _UpperCamelCase:     List[str]							= PNDMScheduler(skip_prk_steps=_lowercase							)
    torch.manual_seed(0							)
    _UpperCamelCase:     List[str]							= AutoencoderKL(
        block_out_channels=[32, 64]		,  in_channels=3		,  out_channels=3		,  down_block_types=['''DownEncoderBlock2D''', '''DownEncoderBlock2D''']		,  up_block_types=['''UpDecoderBlock2D''', '''UpDecoderBlock2D''']		,  latent_channels=4		,  sample_size=128		,  )
    torch.manual_seed(0							)
    _UpperCamelCase:     Optional[int]							= CLIPTextConfig(
        bos_token_id=0		,  eos_token_id=2		,  hidden_size=32		,  intermediate_size=37		,  layer_norm_eps=1E-05		,  num_attention_heads=4		,  num_hidden_layers=5		,  pad_token_id=1		,  vocab_size=1_000		,  hidden_act='''gelu'''		,  projection_dim=512		,  )
    _UpperCamelCase:     Optional[int]							= CLIPTextModel(_lowercase							)
    _UpperCamelCase:     Union[str, Any]							= CLIPTokenizer.from_pretrained('''hf-internal-testing/tiny-random-clip'''							)

    _UpperCamelCase:     Optional[Any]							= {
        '''unet''': unet,
        '''scheduler''': scheduler,
        '''vae''': vae,
        '''text_encoder''': text_encoder,
        '''tokenizer''': tokenizer,
        '''safety_checker''': None,
        '''feature_extractor''': None,
    }
    return components



   def   lowerCAmelCase						(	self					:  Optional[int]		,  _lowercase					:  Any		,  _lowercase					:  int=0							):



    """simple docstring"""



    _UpperCamelCase:     Any							= floats_tensor((1, 3, 32, 32)		,  rng=random.Random(_lowercase							)							).to(_lowercase							)
    _UpperCamelCase:     Union[str, Any]							= image.cpu().permute(0		,  2		,  3		,  1							)[0]
    _UpperCamelCase:     Optional[int]							= Image.fromarray(np.uinta(_lowercase							)							).convert('''RGB'''							).resize((64, 64)							)
    _UpperCamelCase:     Optional[Any]							= Image.fromarray(np.uinta(image + 4							)							).convert('''RGB'''							).resize((64, 64)							)
    if str(_lowercase							).startswith('''mps'''							):
     _UpperCamelCase:     Dict							= torch.manual_seed(_lowercase							)
    else:
     _UpperCamelCase:     Union[str, Any]							= torch.Generator(device=_lowercase							).manual_seed(_lowercase							)
    _UpperCamelCase:     List[str]							= {
        '''prompt''': '''A painting of a squirrel eating a burger''',
        '''image''': init_image,
        '''mask_image''': mask_image,
        '''generator''': generator,
        '''num_inference_steps''': 2,
        '''guidance_scale''': 6.0,
        '''output_type''': '''numpy''',
    }
    return inputs



   def   lowerCAmelCase						(	self					:  List[str]							):



    """simple docstring"""



    _UpperCamelCase:     Dict							= '''cpu'''  # ensure determinism for the device-dependent torch.Generator
    _UpperCamelCase:     str							= self.get_dummy_components()
    _UpperCamelCase:     Any							= StableDiffusionInpaintPipeline(**_lowercase							)
    _UpperCamelCase:     Any							= sd_pipe.to(_lowercase							)
    sd_pipe.set_progress_bar_config(disable=_lowercase							)

    _UpperCamelCase:     Tuple							= self.get_dummy_inputs(_lowercase							)
    _UpperCamelCase:     List[Any]							= sd_pipe(**_lowercase							).images
    _UpperCamelCase:     Optional[Any]							= image[0, -3:, -3:, -1]

    assert image.shape == (1, 64, 64, 3)
    _UpperCamelCase:     List[str]							= np.array([0.4727, 0.5735, 0.3941, 0.5446, 0.5926, 0.4394, 0.5062, 0.4654, 0.4476]							)

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



   def   lowerCAmelCase						(	self					:  Union[str, Any]							):



    """simple docstring"""



    super().test_inference_batch_single_identical(expected_max_diff=3E-3							)




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





   """simple docstring"""




   def   lowerCAmelCase						(	self					:  Dict							):



    """simple docstring"""



    super().tearDown()
    gc.collect()
    torch.cuda.empty_cache()



   def   lowerCAmelCase						(	self					:  Dict							):



    """simple docstring"""



    _UpperCamelCase:     Optional[Any]							= load_image(
        '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
        '''/sd2-inpaint/init_image.png'''							)
    _UpperCamelCase:     Tuple							= load_image(
        '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint/mask.png'''							)
    _UpperCamelCase:     Dict							= load_numpy(
        '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint'''
        '''/yellow_cat_sitting_on_a_park_bench.npy'''							)

    _UpperCamelCase:     Optional[Any]							= '''stabilityai/stable-diffusion-2-inpainting'''
    _UpperCamelCase:     Optional[Any]							= StableDiffusionInpaintPipeline.from_pretrained(_lowercase		,  safety_checker=_lowercase							)
    pipe.to(_lowercase							)
    pipe.set_progress_bar_config(disable=_lowercase							)
    pipe.enable_attention_slicing()

    _UpperCamelCase:     List[str]							= '''Face of a yellow cat, high resolution, sitting on a park bench'''

    _UpperCamelCase:     List[Any]							= torch.manual_seed(0							)
    _UpperCamelCase:     str							= pipe(
        prompt=_lowercase		,  image=_lowercase		,  mask_image=_lowercase		,  generator=_lowercase		,  output_type='''np'''		,  )
    _UpperCamelCase:     Optional[Any]							= output.images[0]

    assert image.shape == (512, 512, 3)
    assert np.abs(expected_image - image							).max() < 9E-3



   def   lowerCAmelCase						(	self					:  List[Any]							):



    """simple docstring"""



    _UpperCamelCase:     Optional[Any]							= load_image(
        '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
        '''/sd2-inpaint/init_image.png'''							)
    _UpperCamelCase:     Union[str, Any]							= load_image(
        '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint/mask.png'''							)
    _UpperCamelCase:     str							= load_numpy(
        '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint'''
        '''/yellow_cat_sitting_on_a_park_bench_fp16.npy'''							)

    _UpperCamelCase:     Optional[Any]							= '''stabilityai/stable-diffusion-2-inpainting'''
    _UpperCamelCase:     int							= StableDiffusionInpaintPipeline.from_pretrained(
        _lowercase		,  torch_dtype=torch.floataa		,  safety_checker=_lowercase		,  )
    pipe.to(_lowercase							)
    pipe.set_progress_bar_config(disable=_lowercase							)
    pipe.enable_attention_slicing()

    _UpperCamelCase:     Optional[Any]							= '''Face of a yellow cat, high resolution, sitting on a park bench'''

    _UpperCamelCase:     Dict							= torch.manual_seed(0							)
    _UpperCamelCase:     int							= pipe(
        prompt=_lowercase		,  image=_lowercase		,  mask_image=_lowercase		,  generator=_lowercase		,  output_type='''np'''		,  )
    _UpperCamelCase:     Optional[Any]							= output.images[0]

    assert image.shape == (512, 512, 3)
    assert np.abs(expected_image - image							).max() < 5E-1



   def   lowerCAmelCase						(	self					:  Any							):



    """simple docstring"""



    torch.cuda.empty_cache()
    torch.cuda.reset_max_memory_allocated()
    torch.cuda.reset_peak_memory_stats()

    _UpperCamelCase:     Union[str, Any]							= load_image(
        '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main'''
        '''/sd2-inpaint/init_image.png'''							)
    _UpperCamelCase:     Optional[Any]							= load_image(
        '''https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint/mask.png'''							)

    _UpperCamelCase:     Optional[int]							= '''stabilityai/stable-diffusion-2-inpainting'''
    _UpperCamelCase:     Union[str, Any]							= PNDMScheduler.from_pretrained(_lowercase		,  subfolder='''scheduler'''							)
    _UpperCamelCase:     Optional[int]							= StableDiffusionInpaintPipeline.from_pretrained(
        _lowercase		,  safety_checker=_lowercase		,  scheduler=_lowercase		,  torch_dtype=torch.floataa		,  )
    pipe.to(_lowercase							)
    pipe.set_progress_bar_config(disable=_lowercase							)
    pipe.enable_attention_slicing(1							)
    pipe.enable_sequential_cpu_offload()

    _UpperCamelCase:     Optional[int]							= '''Face of a yellow cat, high resolution, sitting on a park bench'''

    _UpperCamelCase:     Union[str, Any]							= torch.manual_seed(0							)
    _UpperCamelCase:     Union[str, Any]							= pipe(
        prompt=_lowercase		,  image=_lowercase		,  mask_image=_lowercase		,  generator=_lowercase		,  num_inference_steps=2		,  output_type='''np'''		,  )

    _UpperCamelCase:     Dict							= torch.cuda.max_memory_allocated()
    # make sure that less than 2.65 GB is allocated
    assert mem_bytes < 2.65 * 10**9