




import argparse

import torch

from transformers import (
    EncodecConfig,
    EncodecFeatureExtractor,
    EncodecModel,
    logging,
)


# checkpoints downloaded from:
# https://dl.fbaipublicfiles.com/encodec/v0/encodec_24khz-d7cc33bc.th
# https://huggingface.co/facebook/musicgen-small/resolve/main/compression_state_dict.bin
# https://dl.fbaipublicfiles.com/encodec/v0/encodec_48khz-7e698e3e.th


logging.set_verbosity_info()
lowerCamelCase       :	int									=     logging.get_logger("transformers.models.encodec")

lowerCamelCase       :	Any									=     {
    '''quantizer.vq.layers.*._codebook.inited''': '''quantizer.layers.*.codebook.inited''',
    '''quantizer.vq.layers.*._codebook.cluster_size''': '''quantizer.layers.*.codebook.cluster_size''',
    '''quantizer.vq.layers.*._codebook.embed''': '''quantizer.layers.*.codebook.embed''',
    '''quantizer.vq.layers.*._codebook.embed_avg''': '''quantizer.layers.*.codebook.embed_avg''',
}
lowerCamelCase       :	Dict									=     {
    '''encoder.model.0.conv.conv''': '''encoder.layers.0.conv''',
    '''encoder.model.1.block.1.conv.conv''': '''encoder.layers.1.block.1.conv''',
    '''encoder.model.1.block.3.conv.conv''': '''encoder.layers.1.block.3.conv''',
    '''encoder.model.1.shortcut.conv.conv''': '''encoder.layers.1.shortcut.conv''',
    '''encoder.model.3.conv.conv''': '''encoder.layers.3.conv''',
    '''encoder.model.4.block.1.conv.conv''': '''encoder.layers.4.block.1.conv''',
    '''encoder.model.4.block.3.conv.conv''': '''encoder.layers.4.block.3.conv''',
    '''encoder.model.4.shortcut.conv.conv''': '''encoder.layers.4.shortcut.conv''',
    '''encoder.model.6.conv.conv''': '''encoder.layers.6.conv''',
    '''encoder.model.7.block.1.conv.conv''': '''encoder.layers.7.block.1.conv''',
    '''encoder.model.7.block.3.conv.conv''': '''encoder.layers.7.block.3.conv''',
    '''encoder.model.7.shortcut.conv.conv''': '''encoder.layers.7.shortcut.conv''',
    '''encoder.model.9.conv.conv''': '''encoder.layers.9.conv''',
    '''encoder.model.10.block.1.conv.conv''': '''encoder.layers.10.block.1.conv''',
    '''encoder.model.10.block.3.conv.conv''': '''encoder.layers.10.block.3.conv''',
    '''encoder.model.10.shortcut.conv.conv''': '''encoder.layers.10.shortcut.conv''',
    '''encoder.model.12.conv.conv''': '''encoder.layers.12.conv''',
    '''encoder.model.13.lstm''': '''encoder.layers.13.lstm''',
    '''encoder.model.15.conv.conv''': '''encoder.layers.15.conv''',
}
lowerCamelCase       :	Any									=     {
    '''encoder.model.0.conv.norm''': '''encoder.layers.0.norm''',
    '''encoder.model.1.block.1.conv.norm''': '''encoder.layers.1.block.1.norm''',
    '''encoder.model.1.block.3.conv.norm''': '''encoder.layers.1.block.3.norm''',
    '''encoder.model.1.shortcut.conv.norm''': '''encoder.layers.1.shortcut.norm''',
    '''encoder.model.3.conv.norm''': '''encoder.layers.3.norm''',
    '''encoder.model.4.block.1.conv.norm''': '''encoder.layers.4.block.1.norm''',
    '''encoder.model.4.block.3.conv.norm''': '''encoder.layers.4.block.3.norm''',
    '''encoder.model.4.shortcut.conv.norm''': '''encoder.layers.4.shortcut.norm''',
    '''encoder.model.6.conv.norm''': '''encoder.layers.6.norm''',
    '''encoder.model.7.block.1.conv.norm''': '''encoder.layers.7.block.1.norm''',
    '''encoder.model.7.block.3.conv.norm''': '''encoder.layers.7.block.3.norm''',
    '''encoder.model.7.shortcut.conv.norm''': '''encoder.layers.7.shortcut.norm''',
    '''encoder.model.9.conv.norm''': '''encoder.layers.9.norm''',
    '''encoder.model.10.block.1.conv.norm''': '''encoder.layers.10.block.1.norm''',
    '''encoder.model.10.block.3.conv.norm''': '''encoder.layers.10.block.3.norm''',
    '''encoder.model.10.shortcut.conv.norm''': '''encoder.layers.10.shortcut.norm''',
    '''encoder.model.12.conv.norm''': '''encoder.layers.12.norm''',
    '''encoder.model.15.conv.norm''': '''encoder.layers.15.norm''',
}
lowerCamelCase       :	List[Any]									=     {
    '''decoder.model.0.conv.conv''': '''decoder.layers.0.conv''',
    '''decoder.model.1.lstm''': '''decoder.layers.1.lstm''',
    '''decoder.model.3.convtr.convtr''': '''decoder.layers.3.conv''',
    '''decoder.model.4.block.1.conv.conv''': '''decoder.layers.4.block.1.conv''',
    '''decoder.model.4.block.3.conv.conv''': '''decoder.layers.4.block.3.conv''',
    '''decoder.model.4.shortcut.conv.conv''': '''decoder.layers.4.shortcut.conv''',
    '''decoder.model.6.convtr.convtr''': '''decoder.layers.6.conv''',
    '''decoder.model.7.block.1.conv.conv''': '''decoder.layers.7.block.1.conv''',
    '''decoder.model.7.block.3.conv.conv''': '''decoder.layers.7.block.3.conv''',
    '''decoder.model.7.shortcut.conv.conv''': '''decoder.layers.7.shortcut.conv''',
    '''decoder.model.9.convtr.convtr''': '''decoder.layers.9.conv''',
    '''decoder.model.10.block.1.conv.conv''': '''decoder.layers.10.block.1.conv''',
    '''decoder.model.10.block.3.conv.conv''': '''decoder.layers.10.block.3.conv''',
    '''decoder.model.10.shortcut.conv.conv''': '''decoder.layers.10.shortcut.conv''',
    '''decoder.model.12.convtr.convtr''': '''decoder.layers.12.conv''',
    '''decoder.model.13.block.1.conv.conv''': '''decoder.layers.13.block.1.conv''',
    '''decoder.model.13.block.3.conv.conv''': '''decoder.layers.13.block.3.conv''',
    '''decoder.model.13.shortcut.conv.conv''': '''decoder.layers.13.shortcut.conv''',
    '''decoder.model.15.conv.conv''': '''decoder.layers.15.conv''',
}
lowerCamelCase       :	List[Any]									=     {
    '''decoder.model.0.conv.norm''': '''decoder.layers.0.norm''',
    '''decoder.model.3.convtr.norm''': '''decoder.layers.3.norm''',
    '''decoder.model.4.block.1.conv.norm''': '''decoder.layers.4.block.1.norm''',
    '''decoder.model.4.block.3.conv.norm''': '''decoder.layers.4.block.3.norm''',
    '''decoder.model.4.shortcut.conv.norm''': '''decoder.layers.4.shortcut.norm''',
    '''decoder.model.6.convtr.norm''': '''decoder.layers.6.norm''',
    '''decoder.model.7.block.1.conv.norm''': '''decoder.layers.7.block.1.norm''',
    '''decoder.model.7.block.3.conv.norm''': '''decoder.layers.7.block.3.norm''',
    '''decoder.model.7.shortcut.conv.norm''': '''decoder.layers.7.shortcut.norm''',
    '''decoder.model.9.convtr.norm''': '''decoder.layers.9.norm''',
    '''decoder.model.10.block.1.conv.norm''': '''decoder.layers.10.block.1.norm''',
    '''decoder.model.10.block.3.conv.norm''': '''decoder.layers.10.block.3.norm''',
    '''decoder.model.10.shortcut.conv.norm''': '''decoder.layers.10.shortcut.norm''',
    '''decoder.model.12.convtr.norm''': '''decoder.layers.12.norm''',
    '''decoder.model.13.block.1.conv.norm''': '''decoder.layers.13.block.1.norm''',
    '''decoder.model.13.block.3.conv.norm''': '''decoder.layers.13.block.3.norm''',
    '''decoder.model.13.shortcut.conv.norm''': '''decoder.layers.13.shortcut.norm''',
    '''decoder.model.15.conv.norm''': '''decoder.layers.15.norm''',
}
lowerCamelCase       :	Dict									=     {
    **MAPPING_QUANTIZER,
    **MAPPING_ENCODER,
    **MAPPING_DECODER,
}
lowerCamelCase       :	int									=     {
    **MAPPING_QUANTIZER,
    **MAPPING_ENCODER,
    **MAPPING_ENCODER_48K,
    **MAPPING_DECODER,
    **MAPPING_DECODER_48K,
}
lowerCamelCase       :	str									=     []
lowerCamelCase       :	List[Any]									=     []

def     _SCREAMING_SNAKE_CASE    (							lowercase			: Union[str, Any]			,							lowercase			: Union[str, Any]			,							lowercase			: List[str]			,							lowercase			: int			,							lowercase			: Tuple  ):


      '''simple docstring'''



      for attribute in key.split('.'  ):
            lowerCamelCase_	  =					getattr(_A			,							_A  )

      if weight_type is not None:
            lowerCamelCase_	  =					getattr(_A			,							_A  ).shape
      else:
            lowerCamelCase_	  =					hf_pointer.shape

      if hf_shape != value.shape:
            raise ValueError(
                f"""Shape of hf {key + "." + weight_type if weight_type is not None else ""} is {hf_shape}, but should be"""
                f""" {value.shape} for {full_name}"""  )

      if weight_type == "weight":
            lowerCamelCase_	  =					value
      elif weight_type == "weight_g":
            lowerCamelCase_	  =					value
      elif weight_type == "weight_v":
            lowerCamelCase_	  =					value
      elif weight_type == "bias":
            lowerCamelCase_	  =					value
      elif weight_type == "running_mean":
            lowerCamelCase_	  =					value
      elif weight_type == "running_var":
            lowerCamelCase_	  =					value
      elif weight_type == "num_batches_tracked":
            lowerCamelCase_	  =					value
      elif weight_type == "weight_ih_l0":
            lowerCamelCase_	  =					value
      elif weight_type == "weight_hh_l0":
            lowerCamelCase_	  =					value
      elif weight_type == "bias_ih_l0":
            lowerCamelCase_	  =					value
      elif weight_type == "bias_hh_l0":
            lowerCamelCase_	  =					value
      elif weight_type == "weight_ih_l1":
            lowerCamelCase_	  =					value
      elif weight_type == "weight_hh_l1":
            lowerCamelCase_	  =					value
      elif weight_type == "bias_ih_l1":
            lowerCamelCase_	  =					value
      elif weight_type == "bias_hh_l1":
            lowerCamelCase_	  =					value
      else:
            lowerCamelCase_	  =					value

      logger.info(f"""{key + ("." + weight_type if weight_type is not None else "")} was initialized from {full_name}."""  )

def     _SCREAMING_SNAKE_CASE    (							lowercase			: List[Any]			,							lowercase			: Optional[Any]  ):


      '''simple docstring'''



      for key in ignore_keys:
            if key.endswith('.*'  ):
                  if name.startswith(key[:-1]  ):
                        return True
            elif ".*." in key:
                  lowerCamelCase_  ,       lowerCamelCase_	  =					key.split('.*.'  )
                  if prefix in name and suffix in name:
                        return True
            elif key in name:
                  return True
      return False

def     _SCREAMING_SNAKE_CASE    (							lowercase			: List[Any]			,							lowercase			: Tuple			,							lowercase			: str  ):


      '''simple docstring'''



      lowerCamelCase_	  =					[]

      if model_name == "encodec_24khz" or "encodec_32khz":
            lowerCamelCase_	  =					MAPPING_24K
      elif model_name == "encodec_48khz":
            lowerCamelCase_	  =					MAPPING_48K
      else:
            raise ValueError(f"""Unsupported model: {model_name}"""  )

      for name, value in orig_dict.items():
            if should_ignore(_A			,							_A  ):
                  logger.info(f"""{name} was ignored"""  )
                  continue

            lowerCamelCase_	  =					False
            for key, mapped_key in MAPPING.items():
                  if "*" in key:
                        lowerCamelCase_  ,       lowerCamelCase_	  =					key.split('.*.'  )
                        if prefix in name and suffix in name:
                              lowerCamelCase_	  =					suffix

                  if key in name:
                        # HACK otherwise .embed gets initialized with .embed_avg too
                        if key.endswith('embed'  ) and name.endswith('embed_avg'  ):
                              continue

                        lowerCamelCase_	  =					True
                        if "*" in mapped_key:
                              lowerCamelCase_	  =					name.split(_A  )[0].split('.'  )[-2]
                              lowerCamelCase_	  =					mapped_key.replace('*'			,							_A  )
                        if "weight_g" in name:
                              lowerCamelCase_	  =					'weight_g'
                        elif "weight_v" in name:
                              lowerCamelCase_	  =					'weight_v'
                        elif "weight_ih_l0" in name:
                              lowerCamelCase_	  =					'weight_ih_l0'
                        elif "weight_hh_l0" in name:
                              lowerCamelCase_	  =					'weight_hh_l0'
                        elif "bias_ih_l0" in name:
                              lowerCamelCase_	  =					'bias_ih_l0'
                        elif "bias_hh_l0" in name:
                              lowerCamelCase_	  =					'bias_hh_l0'
                        elif "weight_ih_l1" in name:
                              lowerCamelCase_	  =					'weight_ih_l1'
                        elif "weight_hh_l1" in name:
                              lowerCamelCase_	  =					'weight_hh_l1'
                        elif "bias_ih_l1" in name:
                              lowerCamelCase_	  =					'bias_ih_l1'
                        elif "bias_hh_l1" in name:
                              lowerCamelCase_	  =					'bias_hh_l1'
                        elif "bias" in name:
                              lowerCamelCase_	  =					'bias'
                        elif "weight" in name:
                              lowerCamelCase_	  =					'weight'
                        elif "running_mean" in name:
                              lowerCamelCase_	  =					'running_mean'
                        elif "running_var" in name:
                              lowerCamelCase_	  =					'running_var'
                        elif "num_batches_tracked" in name:
                              lowerCamelCase_	  =					'num_batches_tracked'
                        else:
                              lowerCamelCase_	  =					None
                        set_recursively(_A			,							_A			,							_A			,							_A			,							_A  )
                  continue
            if not is_used:
                  unused_weights.append(_A  )

      logger.warning(f"""Unused weights: {unused_weights}"""  )

@torch.no_grad()
def     _SCREAMING_SNAKE_CASE    (							lowercase			: List[str]			,							lowercase			: List[Any]			,							lowercase			: str			,							lowercase			: Union[str, Any]=None			,							lowercase			: Union[str, Any]=None			,							):


      '''simple docstring'''



      if config_path is not None:
            lowerCamelCase_	  =					EncodecConfig.from_pretrained(_A  )
      else:
            lowerCamelCase_	  =					EncodecConfig()

      if model_name == "encodec_24khz":
            pass  # config is already correct
      elif model_name == "encodec_32khz":
            lowerCamelCase_	  =					[8, 5, 4, 4]
            lowerCamelCase_	  =					[2.2]
            lowerCamelCase_	  =					64
            lowerCamelCase_	  =					3_20_00
            lowerCamelCase_	  =					20_48
            lowerCamelCase_	  =					False
            lowerCamelCase_	  =					False
            lowerCamelCase_	  =					False
      elif model_name == "encodec_48khz":
            lowerCamelCase_	  =					[8, 5, 4, 2]
            lowerCamelCase_	  =					[3.0, 6.0, 12.0, 24.0]
            lowerCamelCase_	  =					4_80_00
            lowerCamelCase_	  =					2
            lowerCamelCase_	  =					False
            lowerCamelCase_	  =					'time_group_norm'
            lowerCamelCase_	  =					True
            lowerCamelCase_	  =					1.0
            lowerCamelCase_	  =					0.01
      else:
            raise ValueError(f"""Unknown model name: {model_name}"""  )

      lowerCamelCase_	  =					EncodecModel(_A  )

      lowerCamelCase_	  =					EncodecFeatureExtractor(
          feature_size=config.audio_channels			,							sampling_rate=config.sampling_rate			,							chunk_length_s=config.chunk_length_s			,							overlap=config.overlap			,							)
      feature_extractor.save_pretrained(_A  )

      lowerCamelCase_	  =					torch.load(_A  )
      if "best_state" in original_checkpoint:
            # we might have a training state saved, in which case discard the yaml results and just retain the weights
            lowerCamelCase_	  =					original_checkpoint['best_state']
      recursively_load_weights(_A			,							_A			,							_A  )
      model.save_pretrained(_A  )

      if repo_id:
            print('Pushing to the hub...'  )
            feature_extractor.push_to_hub(_A  )
            model.push_to_hub(_A  )


if __name__ == "__main__":
   lowerCamelCase       :	Tuple									=     argparse.ArgumentParser()
   parser.add_argument(
       "--model",
       default="encodec_24khz",
       type=str,
       help="The model to convert. Should be one of \'encodec_24khz\', \'encodec_32khz\', \'encodec_48khz\'.",
   )
   parser.add_argument("--checkpoint_path", required=True, default=None, type=str, help="Path to original checkpoint")
   parser.add_argument("--config_path", default=None, type=str, help="Path to hf config.json of model to convert")
   parser.add_argument(
       "--pytorch_dump_folder_path", required=True, default=None, type=str, help="Path to the output PyTorch model."
   )
   parser.add_argument(
       "--push_to_hub", default=None, type=str, help="Where to upload the converted model on the 🤗 hub."
   )

   lowerCamelCase       :	int									=     parser.parse_args()
   convert_checkpoint(
       args.model,
       args.checkpoint_path,
       args.pytorch_dump_folder_path,
       args.config_path,
       args.push_to_hub,
   )









from manim import *







class 						A(		UpperCamelCase     ):



 '''simple docstring'''


 def        a__				(       self      :						Optional[Any]						)     ->			List[str]:

       """simple docstring"""






       lowerCamelCase_	  =					Rectangle(height=0.5		,							width=0.5						)
       lowerCamelCase_	  =					Rectangle(height=0.46		,							width=0.46						).set_stroke(width=0						)

       lowerCamelCase_	  =					Rectangle(height=0.25		,							width=0.25						)

       lowerCamelCase_	  =					[mem.copy() for i in range(6						)]
       lowerCamelCase_	  =					[mem.copy() for i in range(6						)]
       lowerCamelCase_	  =					VGroup(*A_						).arrange(A_		,							buff=0						)
       lowerCamelCase_	  =					VGroup(*A_						).arrange(A_		,							buff=0						)
       lowerCamelCase_	  =					VGroup(A_		,							A_						).arrange(A_		,							buff=0						)
       lowerCamelCase_	  =					Text('CPU'		,							font_size=24						)
       lowerCamelCase_	  =					Group(A_		,							A_						).arrange(A_		,							buff=0.5		,							aligned_edge=A_						)
       cpu.move_to([-2.5, -0.5, 0]						)
       self.add(A_						)

       lowerCamelCase_	  =					[mem.copy() for i in range(4						)]
       lowerCamelCase_	  =					VGroup(*A_						).arrange(A_		,							buff=0						)
       lowerCamelCase_	  =					Text('GPU'		,							font_size=24						)
       lowerCamelCase_	  =					Group(A_		,							A_						).arrange(A_		,							buff=0.5		,							aligned_edge=A_						)
       gpu.move_to([-1, -1, 0]						)
       self.add(A_						)

       lowerCamelCase_	  =					[mem.copy() for i in range(6						)]
       lowerCamelCase_	  =					VGroup(*A_						).arrange(A_		,							buff=0						)

       lowerCamelCase_	  =					Text('Model'		,							font_size=24						)
       lowerCamelCase_	  =					Group(A_		,							A_						).arrange(A_		,							buff=0.5		,							aligned_edge=A_						)
       model.move_to([3, -1.0, 0]						)
       self.add(A_						)

       lowerCamelCase_	  =					[]
       lowerCamelCase_	  =					[]

       for i, rect in enumerate(A_						):
             lowerCamelCase_	  =					fill.copy().set_fill(A_		,							opacity=0.8						)
             target.move_to(A_						)
             model_arr.append(A_						)

             lowerCamelCase_	  =					Rectangle(height=0.46		,							width=0.46						).set_stroke(width=0.0						).set_fill(A_		,							opacity=0.8						)
             cpu_target.move_to(cpu_left_col_base[i]						)
             model_cpu_arr.append(A_						)

       self.add(*A_		,							*A_						)

       lowerCamelCase_	  =					[meta_mem.copy() for i in range(6						)]
       lowerCamelCase_	  =					[meta_mem.copy() for i in range(6						)]
       lowerCamelCase_	  =					VGroup(*A_						).arrange(A_		,							buff=0						)
       lowerCamelCase_	  =					VGroup(*A_						).arrange(A_		,							buff=0						)
       lowerCamelCase_	  =					VGroup(A_		,							A_						).arrange(A_		,							buff=0						)
       lowerCamelCase_	  =					Text('Disk'		,							font_size=24						)
       lowerCamelCase_	  =					Group(A_		,							A_						).arrange(A_		,							buff=0.5		,							aligned_edge=A_						)
       disk.move_to([-4, -1.25, 0]						)
       self.add(A_		,							A_						)

       lowerCamelCase_	  =					Square(side_length=2.2						)
       key.move_to([-5, 2, 0]						)

       lowerCamelCase_	  =					MarkupText(
           f"""<b>Key:</b>\n\n<span fgcolor='{YELLOW}'>●</span> Empty Model"""		,							font_size=18		,							)

       key_text.move_to([-5, 2.4, 0]						)

       self.add(A_		,							A_						)

       lowerCamelCase_	  =					MarkupText(
           f"""<span fgcolor='{BLUE}'>●</span> Checkpoint"""		,							font_size=18		,							)

       blue_text.next_to(A_		,							DOWN * 2.4		,							aligned_edge=key_text.get_left()						)
       self.add(A_						)

       lowerCamelCase_	  =					MarkupText(
           f"""Now watch as an input is passed through the model\nand how the memory is utilized and handled."""		,							font_size=24		,							)
       step_a.move_to([2, 2, 0]						)

       self.play(Write(A_						)						)

       lowerCamelCase_	  =					Square(0.3						)
       input.set_fill(A_		,							opacity=1.0						)
       input.set_stroke(width=0.0						)
       input.next_to(model_base[0]		,							A_		,							buff=0.5						)

       self.play(Write(A_						)						)

       input.generate_target()
       input.target.next_to(model_arr[0]		,							direction=A_		,							buff=0.02						)
       self.play(MoveToTarget(A_						)						)

       self.play(FadeOut(A_						)						)

       lowerCamelCase_	  =					Arrow(start=A_		,							end=A_		,							color=A_		,							buff=0.5						)
       a.next_to(model_arr[0].get_left()		,							A_		,							buff=0.2						)

       model_cpu_arr[0].generate_target()
       model_cpu_arr[0].target.move_to(gpu_rect[0]						)

       lowerCamelCase_	  =					MarkupText(
           f"""As the input reaches a layer, the hook triggers\nand weights are moved from the CPU\nto the GPU and back."""		,							font_size=24		,							)
       step_a.move_to([2, 2, 0]						)

       self.play(Write(A_		,							run_time=3						)						)

       lowerCamelCase_	  =					{'run_time': 1, 'fade_in': True, 'fade_out': True, 'buff': 0.02}

       self.play(
           Write(A_						)		,							Circumscribe(model_arr[0]		,							color=A_		,							**A_						)		,							Circumscribe(model_cpu_arr[0]		,							color=A_		,							**A_						)		,							Circumscribe(gpu_rect[0]		,							color=A_		,							**A_						)		,							)
       self.play(MoveToTarget(model_cpu_arr[0]						)						)

       lowerCamelCase_	  =					a.copy()
       for i in range(6						):
             a_c.next_to(model_arr[i].get_right() + 0.02		,							A_		,							buff=0.2						)

             input.generate_target()
             input.target.move_to(model_arr[i].get_right() + 0.02						)

             lowerCamelCase_	  =					AnimationGroup(
                 FadeOut(A_		,							run_time=0.5						)		,							MoveToTarget(A_		,							run_time=0.5						)		,							FadeIn(A_		,							run_time=0.5						)		,							lag_ratio=0.2						)

             self.play(A_						)

             model_cpu_arr[i].generate_target()
             model_cpu_arr[i].target.move_to(cpu_left_col_base[i]						)

             if i < 5:
                   model_cpu_arr[i + 1].generate_target()
                   model_cpu_arr[i + 1].target.move_to(gpu_rect[0]						)
                   if i >= 1:
                         lowerCamelCase_	  =					0.7

                   self.play(
                       Circumscribe(model_arr[i]		,							**A_						)		,							Circumscribe(cpu_left_col_base[i]		,							**A_						)		,							Circumscribe(cpu_left_col_base[i + 1]		,							color=A_		,							**A_						)		,							Circumscribe(gpu_rect[0]		,							color=A_		,							**A_						)		,							Circumscribe(model_arr[i + 1]		,							color=A_		,							**A_						)		,							)
                   if i < 1:
                         self.play(
                             MoveToTarget(model_cpu_arr[i]						)		,							MoveToTarget(model_cpu_arr[i + 1]						)		,							)
                   else:
                         self.play(
                             MoveToTarget(model_cpu_arr[i]		,							run_time=0.7						)		,							MoveToTarget(model_cpu_arr[i + 1]		,							run_time=0.7						)		,							)
             else:
                   model_cpu_arr[i].generate_target()
                   model_cpu_arr[i].target.move_to(cpu_left_col_base[-1]						)
                   input.generate_target()
                   input.target.next_to(model_arr[-1].get_right()		,							RIGHT + 0.02		,							buff=0.2						)

                   self.play(
                       Circumscribe(model_arr[-1]		,							color=A_		,							**A_						)		,							Circumscribe(cpu_left_col_base[-1]		,							color=A_		,							**A_						)		,							Circumscribe(gpu_rect[0]		,							color=A_		,							**A_						)		,							)

                   self.play(MoveToTarget(model_cpu_arr[i]						)						)

             lowerCamelCase_	  =					a_c
             lowerCamelCase_	  =					a_c.copy()

       input.generate_target()
       input.target.next_to(model_base[-1]		,							RIGHT + 0.02		,							buff=0.5						)
       self.play(
           FadeOut(A_						)		,							FadeOut(A_		,							run_time=0.5						)		,							)

       lowerCamelCase_	  =					MarkupText(f"""Inference on a model too large for GPU memory\nis successfully completed."""		,							font_size=24						)
       step_a.move_to([2, 2, 0]						)

       self.play(Write(A_		,							run_time=3						)		,							MoveToTarget(A_						)						)

       self.wait()



