



from manim import *



class   UpperCAmelCase_    (       _UpperCAmelCase):







							def    snake_case__      (   self):

														'''simple docstring'''

														_lowerCAmelCase     :							List[str]    =    Rectangle(height=0.5,			width=0.5)
														_lowerCAmelCase     :							Dict    =    Rectangle(height=0.25,			width=0.25)
														_lowerCAmelCase     :							Optional[Any]    =    Rectangle(height=0.46,			width=0.46).set_stroke(width=0)

														_lowerCAmelCase     :							Optional[int]    =    [mem.copy() for i in range(6)]
														_lowerCAmelCase     :							Optional[Any]    =    [mem.copy() for i in range(6)]
														_lowerCAmelCase     :							str    =    VGroup(*a__).arrange(a__,			buff=0)
														_lowerCAmelCase     :							List[Any]    =    VGroup(*a__).arrange(a__,			buff=0)
														_lowerCAmelCase     :							Union[str, Any]    =    VGroup(a__,			a__).arrange(a__,			buff=0)
														_lowerCAmelCase     :							Tuple    =    Text("CPU",			font_size=24)
														_lowerCAmelCase     :							Optional[Any]    =    Group(a__,			a__).arrange(a__,			buff=0.5,			aligned_edge=a__)
														cpu.move_to([-2.5, -0.5, 0])
														self.add(a__)

														_lowerCAmelCase     :							Optional[Any]    =    [mem.copy() for i in range(4)]
														_lowerCAmelCase     :							Tuple    =    VGroup(*a__).arrange(a__,			buff=0)
														_lowerCAmelCase     :							int    =    Text("GPU",			font_size=24)
														_lowerCAmelCase     :							Optional[int]    =    Group(a__,			a__).arrange(a__,			buff=0.5,			aligned_edge=a__)
														gpu.move_to([-1, -1, 0])
														self.add(a__)

														_lowerCAmelCase     :							Optional[Any]    =    [mem.copy() for i in range(6)]
														_lowerCAmelCase     :							str    =    VGroup(*a__).arrange(a__,			buff=0)

														_lowerCAmelCase     :							List[str]    =    Text("Model",			font_size=24)
														_lowerCAmelCase     :							Optional[Any]    =    Group(a__,			a__).arrange(a__,			buff=0.5,			aligned_edge=a__)
														model.move_to([3, -1.0, 0])
														self.add(a__)

														_lowerCAmelCase     :							List[Any]    =    []
														_lowerCAmelCase     :							Union[str, Any]    =    []
														_lowerCAmelCase     :							Tuple    =    []

														for i, rect in enumerate(a__):
																					rect.set_stroke(a__)

																					_lowerCAmelCase     :							Union[str, Any]    =    Rectangle(height=0.46 / 4,			width=0.46 / 3).set_stroke(width=0.0).set_fill(a__,			opacity=0.7)

																					if i == 0:
																												cpu_target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT),			buff=0.02,			direction=a__)
																												cpu_target.set_x(cpu_target.get_x() + 0.1)
																					elif i == 3:
																												cpu_target.next_to(model_cpu_arr[0],			direction=a__,			buff=0.0)
																					else:
																												cpu_target.next_to(model_cpu_arr[i - 1],			direction=a__,			buff=0.0)
																					self.add(a__)
																					model_cpu_arr.append(a__)

														self.add(*a__,			*a__,			*a__)

														_lowerCAmelCase     :							int    =    [mem.copy() for i in range(6)]
														_lowerCAmelCase     :							Optional[int]    =    VGroup(*a__).arrange(a__,			buff=0)

														_lowerCAmelCase     :							str    =    Text("Loaded Checkpoint",			font_size=24)
														_lowerCAmelCase     :							Dict    =    Group(a__,			a__).arrange(a__,			buff=0.5,			aligned_edge=a__)
														checkpoint.move_to([3, 0.5, 0])

														self.add(a__)

														_lowerCAmelCase     :							Optional[Any]    =    []
														_lowerCAmelCase     :							Optional[Any]    =    []

														for i, rect in enumerate(a__):
																					_lowerCAmelCase     :							Optional[Any]    =    fill.copy().set_fill(a__,			opacity=0.7)
																					target.move_to(a__)
																					ckpt_arr.append(a__)

																					_lowerCAmelCase     :							Tuple    =    target.copy()
																					if i < 5:
																												cpu_target.move_to(cpu_left_col_base[i + 1])
																					else:
																												cpu_target.move_to(cpu_right_col_base[i - 5])
																					ckpt_cpu_arr.append(a__)
														self.add(*a__,			*a__)

														_lowerCAmelCase     :							Union[str, Any]    =    Square(side_length=2.2)
														key.move_to([-5, 2, 0])

														_lowerCAmelCase     :							Any    =    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     :							List[Any]    =    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     :							List[Any]    =    MarkupText(
														    f"Based on the passed in configuration, weights are stored in\na variety of np.memmaps on disk or to a particular device.",			font_size=24,			)
														step_a.move_to([2, 2, 0])

														_lowerCAmelCase     :							Dict    =    [meta_mem.copy() for i in range(6)]
														_lowerCAmelCase     :							Optional[int]    =    [meta_mem.copy() for i in range(6)]
														_lowerCAmelCase     :							Union[str, Any]    =    VGroup(*a__).arrange(a__,			buff=0)
														_lowerCAmelCase     :							Dict    =    VGroup(*a__).arrange(a__,			buff=0)
														_lowerCAmelCase     :							Union[str, Any]    =    VGroup(a__,			a__).arrange(a__,			buff=0)
														_lowerCAmelCase     :							Optional[int]    =    Text("Disk",			font_size=24)
														_lowerCAmelCase     :							str    =    Group(a__,			a__).arrange(a__,			buff=0.5,			aligned_edge=a__)
														disk.move_to([-4.0, -1.25, 0])
														self.play(Write(a__,			run_time=3),			Write(a__,			run_time=1),			Create(a__,			run_time=1))

														_lowerCAmelCase     :							Optional[int]    =    []
														for i, rect in enumerate(a__):
																					_lowerCAmelCase     :							Tuple    =    rect.copy()
																					target.generate_target()
																					target.target.move_to(disk_left_col_base[i]).scale(0.5)
																					animations.append(MoveToTarget(a__,			run_time=1.5))
														self.play(*a__)

														self.play(FadeOut(a__))

														_lowerCAmelCase     :							Dict    =    MarkupText(f"Then, the checkpoint is removed from memory\nthrough garbage collection.",			font_size=24)
														step_a.move_to([2, 2, 0])

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

														self.play(
														    FadeOut(a__,			a__,			*a__,			*a__),			)

														self.wait()







import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
    import torch

    from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin

class 		SCREAMING_SNAKE_CASE__				:


      def __init__(self       :      str				,			a__       :      Dict				,			a__       :      Tuple=None				,			a__       :      List[Any]=None				,			a__       :      Dict=None				,			a__       :      Union[str, Any]="resnet50"				,			a__       :      Dict=3				,			a__       :      str=32				,			a__       :      int=3				,			a__       :      Dict=True				,			a__       :      Any=True				,			):





         """simple docstring"""



         __snake_case							       =   parent
         __snake_case							       =   out_indices if out_indices is not None else [4]
         __snake_case							       =   stage_names
         __snake_case							       =   out_features
         __snake_case							       =   backbone
         __snake_case							       =   batch_size
         __snake_case							       =   image_size
         __snake_case							       =   num_channels
         __snake_case							       =   use_pretrained_backbone
         __snake_case							       =   is_training


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





         """simple docstring"""



         __snake_case							       =   floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )
         __snake_case							       =   self.get_config()

         return config, pixel_values


      def    a (self       :      Any      ):





         """simple docstring"""



         return TimmBackboneConfig(
             image_size=self.image_size				,			num_channels=self.num_channels				,			out_features=self.out_features				,			out_indices=self.out_indices				,			stage_names=self.stage_names				,			use_pretrained_backbone=self.use_pretrained_backbone				,			backbone=self.backbone				,			)


      def    a (self       :      List[Any]				,			a__       :      int				,			a__       :      int      ):





         """simple docstring"""



         __snake_case							       =   TimmBackbone(config=a__      )
         model.to(a__      )
         model.eval()
         with torch.no_grad():
            __snake_case							       =   model(a__      )
         self.parent.assertEqual(
             result.feature_map[-1].shape				,			(self.batch_size, model.channels[-1], 14, 14)				,			)


      def    a (self       :      str      ):





         """simple docstring"""



         __snake_case							       =   self.prepare_config_and_inputs()
         __snake_case       ,	__snake_case							       =   config_and_inputs
         __snake_case							       =   {'''pixel_values''': pixel_values}
         return config, inputs_dict






@require_torch
@require_timm
class 		SCREAMING_SNAKE_CASE__				(       _UpperCAmelCase						,      _UpperCAmelCase						,      _UpperCAmelCase						,      unittest.TestCase  ):
      A_						:				Union[str, Any]							=    (TimmBackbone,) if is_torch_available() else ()
      A_						:				Optional[Any]							=    {'feature-extraction': TimmBackbone} if is_torch_available() else {}
      A_						:				List[Any]							=    False
      A_						:				Dict							=    False
      A_						:				Any							=    False
      A_						:				List[Any]							=    False


      def    a (self       :      Tuple      ):





         """simple docstring"""



         __snake_case							       =   TimmBackboneModelTester(self      )
         __snake_case							       =   ConfigTester(self				,			config_class=a__				,			has_text_modality=a__      )


      def    a (self       :      Any      ):





         """simple docstring"""



         self.config_tester.create_and_test_config_to_json_string()
         self.config_tester.create_and_test_config_to_json_file()
         self.config_tester.create_and_test_config_from_and_save_pretrained()
         self.config_tester.create_and_test_config_with_num_labels()
         self.config_tester.check_config_can_be_init_without_params()
         self.config_tester.check_config_arguments_init()


      def    a (self       :      int      ):





         """simple docstring"""



         __snake_case							       =   '''resnet18'''
         __snake_case							       =   '''microsoft/resnet-18'''

         __snake_case							       =   AutoBackbone.from_pretrained(a__				,			use_timm_backbone=a__      )
         __snake_case							       =   AutoBackbone.from_pretrained(a__      )

         self.assertEqual(len(timm_model.out_features      )				,			len(transformers_model.out_features      )      )
         self.assertEqual(len(timm_model.stage_names      )				,			len(transformers_model.stage_names      )      )
         self.assertEqual(timm_model.channels				,			transformers_model.channels      )
         # Out indices are set to the last layer by default. For timm models, we don't know
         # the number of layers in advance, so we set it to (-1,), whereas for transformers
         # models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
         self.assertEqual(timm_model.out_indices				,			(-1,)      )
         self.assertEqual(transformers_model.out_indices				,			[len(timm_model.stage_names      ) - 1]      )

         __snake_case							       =   AutoBackbone.from_pretrained(a__				,			use_timm_backbone=a__				,			out_indices=[1, 2, 3]      )
         __snake_case							       =   AutoBackbone.from_pretrained(a__				,			out_indices=[1, 2, 3]      )

         self.assertEqual(timm_model.out_indices				,			transformers_model.out_indices      )
         self.assertEqual(len(timm_model.out_features      )				,			len(transformers_model.out_features      )      )
         self.assertEqual(timm_model.channels				,			transformers_model.channels      )


      @unittest.skip('''TimmBackbone doesn\'t support feed forward chunking'''      )
      def    a (self       :      str      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone doesn\'t have num_hidden_layers attribute'''      )
      def    a (self       :      int      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone initialization is managed on the timm side'''      )
      def    a (self       :      Union[str, Any]      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''      )
      def    a (self       :      Optional[int]      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''      )
      def    a (self       :      int      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone model cannot be created without specifying a backbone checkpoint'''      )
      def    a (self       :      Tuple      ):





         """simple docstring"""



         pass


      @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''      )
      def    a (self       :      int      ):





         """simple docstring"""



         pass


      @unittest.skip('''model weights aren\'t tied in TimmBackbone.'''      )
      def    a (self       :      Optional[Any]      ):





         """simple docstring"""



         pass


      @unittest.skip('''model weights aren\'t tied in TimmBackbone.'''      )
      def    a (self       :      Tuple      ):





         """simple docstring"""



         pass


      @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''      )
      def    a (self       :      Dict      ):





         """simple docstring"""



         pass


      @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''      )
      def    a (self       :      List[Any]      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone doesn\'t have hidden size info in its configuration.'''      )
      def    a (self       :      Optional[Any]      ):





         """simple docstring"""



         pass


      @unittest.skip('''TimmBackbone doesn\'t support output_attentions.'''      )
      def    a (self       :      List[Any]      ):





         """simple docstring"""



         pass


      @unittest.skip('''Safetensors is not supported by timm.'''      )
      def    a (self       :      Tuple      ):





         """simple docstring"""



         pass


      @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''      )
      def    a (self       :      Tuple      ):





         """simple docstring"""



         pass


      def    a (self       :      Tuple      ):





         """simple docstring"""



         __snake_case       ,	__snake_case							       =   self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
            __snake_case							       =   model_class(a__      )
            __snake_case							       =   inspect.signature(model.forward      )
            # signature.parameters is an OrderedDict => so arg_names order is deterministic
            __snake_case							       =   [*signature.parameters.keys()]

            __snake_case							       =   ['''pixel_values''']
            self.assertListEqual(arg_names[:1]				,			a__      )


      def    a (self       :      Dict      ):





         """simple docstring"""



         __snake_case       ,	__snake_case							       =   self.model_tester.prepare_config_and_inputs_for_common()
         __snake_case							       =   True
         __snake_case							       =   self.has_attentions

         # no need to test all models as different heads yield the same functionality
         __snake_case							       =   self.all_model_classes[0]
         __snake_case							       =   model_class(a__      )
         model.to(a__      )

         __snake_case							       =   self._prepare_for_class(a__				,			a__      )
         __snake_case							       =   model(**a__      )
         __snake_case							       =   outputs[0][-1]

         # Encoder-/Decoder-only models
         __snake_case							       =   outputs.hidden_states[0]
         hidden_states.retain_grad()

         if self.has_attentions:
            __snake_case							       =   outputs.attentions[0]
            attentions.retain_grad()

         output.flatten()[0].backward(retain_graph=a__      )

         self.assertIsNotNone(hidden_states.grad      )

         if self.has_attentions:
            self.assertIsNotNone(attentions.grad      )


      def    a (self       :      Optional[int]      ):





         """simple docstring"""



         __snake_case       ,	__snake_case							       =   self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
            __snake_case							       =   model_class(a__      )
            model.to(a__      )
            model.eval()
            __snake_case							       =   model(**a__      )

            self.assertEqual(len(result.feature_maps      )				,			len(config.out_indices      )      )
            self.assertEqual(len(model.channels      )				,			len(config.out_indices      )      )

            # Check output of last stage is taken if out_features=None, out_indices=None
            __snake_case							       =   copy.deepcopy(a__      )
            __snake_case							       =   None
            __snake_case							       =   model_class(a__      )
            model.to(a__      )
            model.eval()
            __snake_case							       =   model(**a__      )

            self.assertEqual(len(result.feature_maps      )				,			1      )
            self.assertEqual(len(model.channels      )				,			1      )

            # Check backbone can be initialized with fresh weights
            __snake_case							       =   copy.deepcopy(a__      )
            __snake_case							       =   False
            __snake_case							       =   model_class(a__      )
            model.to(a__      )
            model.eval()
            __snake_case							       =   model(**a__      )

