"""simple docstring"""


import unittest
from unittest.util import safe_repr

from transformers import AutoTokenizer, RwkvConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch

    from transformers import (
        RWKV_PRETRAINED_MODEL_ARCHIVE_LIST,
        RwkvForCausalLM,
        RwkvModel,
    )
    from transformers.pytorch_utils import is_torch_greater_or_equal_than_2_0
else:
    __UpperCamelCase										=     False




class 					UpperCamelCase   :







       def __init__(					self,				lowerCAmelCase__,				lowerCAmelCase__=14,				lowerCAmelCase__=7,				lowerCAmelCase__=True,				lowerCAmelCase__=False,				lowerCAmelCase__=True,				lowerCAmelCase__=True,				lowerCAmelCase__=True,				lowerCAmelCase__=99,				lowerCAmelCase__=32,				lowerCAmelCase__=5,				lowerCAmelCase__=37,				lowerCAmelCase__="gelu",				lowerCAmelCase__=0.1,				lowerCAmelCase__=0.1,				lowerCAmelCase__=512,				lowerCAmelCase__=16,				lowerCAmelCase__=2,				lowerCAmelCase__=3,				lowerCAmelCase__=4,				lowerCAmelCase__=None,				) -> Optional[int]:
            snake_case_   			=   parent
            snake_case_   			=   batch_size
            snake_case_   			=   seq_length
            snake_case_   			=   is_training
            snake_case_   			=   use_token_type_ids
            snake_case_   			=   use_input_mask
            snake_case_   			=   use_labels
            snake_case_   			=   use_mc_token_ids
            snake_case_   			=   vocab_size
            snake_case_   			=   hidden_size
            snake_case_   			=   num_hidden_layers
            snake_case_   			=   intermediate_size
            snake_case_   			=   hidden_act
            snake_case_   			=   hidden_dropout_prob
            snake_case_   			=   attention_probs_dropout_prob
            snake_case_   			=   max_position_embeddings
            snake_case_   			=   type_vocab_size
            snake_case_   			=   type_sequence_label_size
            snake_case_   			=   num_labels
            snake_case_   			=   num_choices
            snake_case_   			=   scope
            snake_case_   			=   vocab_size - 1
            snake_case_   			=   vocab_size - 1
            snake_case_   			=   vocab_size - 1







       def 						a_		(					self) -> str:
            return RwkvConfig.from_pretrained('sgugger/rwkv-4-pile-7b')







       def 						a_		(					self,				lowerCAmelCase__=False,				lowerCAmelCase__=False,				lowerCAmelCase__=False) -> Tuple:
            snake_case_   			=   ids_tensor([self.batch_size, self.seq_length],				self.vocab_size)

            snake_case_   			=   None
            if self.use_input_mask:
                 snake_case_   			=   random_attention_mask([self.batch_size, self.seq_length])

            snake_case_   			=   None
            if self.use_token_type_ids:
                 snake_case_   			=   ids_tensor([self.batch_size, self.seq_length],				self.type_vocab_size)

            snake_case_   			=   None
            if self.use_mc_token_ids:
                 snake_case_   			=   ids_tensor([self.batch_size, self.num_choices],				self.seq_length)

            snake_case_   			=   None
            snake_case_   			=   None
            snake_case_   			=   None
            if self.use_labels:
                 snake_case_   			=   ids_tensor([self.batch_size],				self.type_sequence_label_size)
                 snake_case_   			=   ids_tensor([self.batch_size, self.seq_length],				self.num_labels)
                 snake_case_   			=   ids_tensor([self.batch_size],				self.num_choices)

            snake_case_   			=   self.get_config(
                gradient_checkpointing=lowerCAmelCase__,				scale_attn_by_inverse_layer_idx=lowerCAmelCase__,				reorder_and_upcast_attn=lowerCAmelCase__,				)

            return (
                config,
                input_ids,
                input_mask,
                None,
                token_type_ids,
                mc_token_ids,
                sequence_labels,
                token_labels,
                choice_labels,
            )







       def 						a_		(					self,				lowerCAmelCase__=False,				lowerCAmelCase__=False,				lowerCAmelCase__=False) -> Union[str, Any]:
            return RwkvConfig(
                vocab_size=self.vocab_size,				hidden_size=self.hidden_size,				num_hidden_layers=self.num_hidden_layers,				intermediate_size=self.intermediate_size,				activation_function=self.hidden_act,				resid_pdrop=self.hidden_dropout_prob,				attn_pdrop=self.attention_probs_dropout_prob,				n_positions=self.max_position_embeddings,				type_vocab_size=self.type_vocab_size,				use_cache=lowerCAmelCase__,				bos_token_id=self.bos_token_id,				eos_token_id=self.eos_token_id,				pad_token_id=self.pad_token_id,				gradient_checkpointing=lowerCAmelCase__,				scale_attn_by_inverse_layer_idx=lowerCAmelCase__,				reorder_and_upcast_attn=lowerCAmelCase__,				)







       def 						a_		(					self) -> Dict:
            snake_case_   			=   self.get_config()
            snake_case_   			=   300
            return config







       def 						a_		(					self) -> Union[str, Any]:
            (
                snake_case_							
            )   			=   self.prepare_config_and_inputs()

            snake_case_   			=   floats_tensor([self.batch_size, self.seq_length, self.hidden_size])
            snake_case_   			=   ids_tensor([self.batch_size, self.seq_length],				vocab_size=2)

            return (
                config,
                input_ids,
                input_mask,
                head_mask,
                token_type_ids,
                sequence_labels,
                token_labels,
                choice_labels,
                encoder_hidden_states,
                encoder_attention_mask,
            )







       def 						a_		(					self,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				*lowerCAmelCase__) -> str:
            snake_case_   			=   True
            snake_case_   			=   RwkvModel(config=lowerCAmelCase__)
            model.to(lowerCAmelCase__)
            model.eval()

            snake_case_   			=   model(lowerCAmelCase__)

            self.parent.assertEqual(result.last_hidden_state.shape,				(self.batch_size, self.seq_length, self.hidden_size))
            self.parent.assertEqual(len(result.hidden_states),				config.num_hidden_layers + 1)







       def 						a_		(					self,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				*lowerCAmelCase__) -> str:
            snake_case_   			=   RwkvForCausalLM(lowerCAmelCase__)
            model.to(lowerCAmelCase__)
            model.eval()

            snake_case_   			=   model(lowerCAmelCase__,				labels=lowerCAmelCase__)
            self.parent.assertEqual(result.loss.shape,				())
            self.parent.assertEqual(result.logits.shape,				(self.batch_size, self.seq_length, self.vocab_size))







       def 						a_		(					self,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				*lowerCAmelCase__) -> Optional[Any]:
            snake_case_   			=   RwkvModel(config=lowerCAmelCase__)
            model.to(lowerCAmelCase__)
            model.eval()

            snake_case_   			=   model(lowerCAmelCase__)
            snake_case_   			=   outputs.last_hidden_state

            snake_case_   			=   model(input_ids[:, :2])
            snake_case_   			=   outputs.last_hidden_state

            # Using the state computed on the first inputs, we will get the same output
            snake_case_   			=   model(input_ids[:, 2:],				state=outputs.state)
            snake_case_   			=   outputs.last_hidden_state

            self.parent.assertTrue(torch.allclose(torch.cat([output_one, output_two],				dim=1),				lowerCAmelCase__,				atol=1e-5))







       def 						a_		(					self,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__,				*lowerCAmelCase__,				lowerCAmelCase__=False) -> Optional[int]:
            snake_case_   			=   RwkvForCausalLM(lowerCAmelCase__)
            model.to(lowerCAmelCase__)
            if gradient_checkpointing:
                 model.gradient_checkpointing_enable()

            snake_case_   			=   model(lowerCAmelCase__,				labels=lowerCAmelCase__)
            self.parent.assertEqual(result.loss.shape,				())
            self.parent.assertEqual(result.logits.shape,				(self.batch_size, self.seq_length, self.vocab_size))
            result.loss.backward()







       def 						a_		(					self) -> List[str]:
            snake_case_   			=   self.prepare_config_and_inputs()

            (
                snake_case_							
            )   			=   config_and_inputs

            snake_case_   			=   {'''input_ids''': input_ids}

            return config, inputs_dict




@unittest.skipIf(
    not is_torch_greater_or_equal_than_2_0       ,						reason="See https://github.com/huggingface/transformers/pull/24204"  )
@require_torch
class 					UpperCamelCase   (							lowerCAmelCase__       ,						lowerCAmelCase__       ,						lowerCAmelCase__       ,						unittest.TestCase  ):
       SCREAMING_SNAKE_CASE_						      = (RwkvModel, RwkvForCausalLM) if is_torch_available() else ()
       SCREAMING_SNAKE_CASE_						      = (
           {"feature-extraction": RwkvModel, "text-generation": RwkvForCausalLM} if is_torch_available() else {}
       )
       # all_generative_model_classes = (RwkvForCausalLM,) if is_torch_available() else ()
       SCREAMING_SNAKE_CASE_						      = False
       SCREAMING_SNAKE_CASE_						      = False
       SCREAMING_SNAKE_CASE_						      = False
       SCREAMING_SNAKE_CASE_						      = False
       SCREAMING_SNAKE_CASE_						      = False  # Rwkv does not support head masking







       def 						a_		(					self) -> List[Any]:
            snake_case_   			=   RwkvModelTester(self)
            snake_case_   			=   ConfigTester(
                self,				config_class=lowerCAmelCase__,				n_embd=37,				common_properties=['hidden_size', 'num_hidden_layers'])







       def 						a_		(					self,				lowerCAmelCase__,				lowerCAmelCase__,				lowerCAmelCase__=None) -> List[str]:
            if isinstance(lowerCAmelCase__,				torch.Tensor):
                 snake_case_   			=   member.max().item(), member.min().item()
            elif isinstance(lowerCAmelCase__,				lowerCAmelCase__) or isinstance(lowerCAmelCase__,				lowerCAmelCase__):
                 snake_case_   			=   max(lowerCAmelCase__), min(lowerCAmelCase__)

            if not isinstance(lowerCAmelCase__,				lowerCAmelCase__):
                 raise TypeError('container should be a list or tuple')
            elif len(lowerCAmelCase__) != 2:
                 raise ValueError('container should have 2 elements')

            snake_case_   			=   container

            snake_case_   			=   (min_value >= expected_min) and (max_value <= expected_max)

            if not is_inside_interval:
                 snake_case_   			=   '''%s not found in %s''' % (safe_repr(lowerCAmelCase__), safe_repr(lowerCAmelCase__))
                 self.fail(self._formatMessage(lowerCAmelCase__,				lowerCAmelCase__))







       def 						a_		(					self) -> List[Any]:
            self.config_tester.run_common_tests()







       def 						a_		(					self) -> List[Any]:
            snake_case_   			=   self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_rwkv_model(*lowerCAmelCase__)







       def 						a_		(					self) -> List[str]:
            snake_case_   			=   self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_causl_lm(*lowerCAmelCase__)







       def 						a_		(					self) -> List[Any]:
            snake_case_   			=   self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_state_equivalency(*lowerCAmelCase__)







       def 						a_		(					self) -> Optional[Any]:
            snake_case_   			=   self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                 snake_case_   			=   model_class(config=lowerCAmelCase__)
                 for name, param in model.named_parameters():
                      if "time_decay" in name:
                           if param.requires_grad:
                                self.assertTrue(param.data.max().item() == 3.0)
                                self.assertTrue(param.data.min().item() == -5.0)
                      elif "time_first" in name:
                           if param.requires_grad:
                                # check if it's a ones like
                                self.assertTrue(torch.allclose(param.data,				torch.ones_like(param.data),				atol=1e-5,				rtol=1e-5))
                      elif any(x in name for x in ['time_mix_key', 'time_mix_receptance']):
                           if param.requires_grad:
                                self.assertInterval(
                                    param.data,				[0.0, 1.0],				msg=f'Parameter {name} of model {model_class} seems not properly initialized',				)
                      elif "time_mix_value" in name:
                           if param.requires_grad:
                                self.assertInterval(
                                    param.data,				[0.0, 1.3],				msg=f'Parameter {name} of model {model_class} seems not properly initialized',				)







       def 						a_		(					self) -> Union[str, Any]:
            snake_case_   			=   self.model_tester.prepare_config_and_inputs_for_common()
            snake_case_   			=   True

            snake_case_   			=   getattr(self.model_tester,				'seq_length',				lowerCAmelCase__)

            for model_class in self.all_model_classes:
                 snake_case_   			=   True
                 snake_case_   			=   False
                 snake_case_   			=   True
                 snake_case_   			=   model_class(lowerCAmelCase__)
                 model.to(lowerCAmelCase__)
                 model.eval()

                 snake_case_   			=   self._prepare_for_class(lowerCAmelCase__,				lowerCAmelCase__)
                 snake_case_   			=   inputs['''input_ids'''].shape[0]
                 with torch.no_grad():
                      snake_case_   			=   model(**lowerCAmelCase__)
                 snake_case_   			=   outputs.attentions
                 self.assertEqual(len(lowerCAmelCase__),				self.model_tester.num_hidden_layers)

                 # check that output_attentions also work using config
                 del inputs_dict["output_attentions"]
                 snake_case_   			=   True
                 snake_case_   			=   model_class(lowerCAmelCase__)
                 model.to(lowerCAmelCase__)
                 model.eval()

                 snake_case_   			=   self._prepare_for_class(lowerCAmelCase__,				lowerCAmelCase__)
                 snake_case_   			=   inputs['''input_ids'''].shape[0]
                 with torch.no_grad():
                      snake_case_   			=   model(**lowerCAmelCase__)
                 snake_case_   			=   outputs.attentions
                 self.assertEqual(len(lowerCAmelCase__),				self.model_tester.num_hidden_layers)

                 self.assertListEqual(
                     list(attentions[0].shape[-3:]),				[batch_size, seq_len, config.hidden_size],				)
                 snake_case_   			=   len(lowerCAmelCase__)

                 # Check attention is always last and order is fine
                 snake_case_   			=   True
                 snake_case_   			=   True
                 snake_case_   			=   model_class(lowerCAmelCase__)
                 model.to(lowerCAmelCase__)
                 model.eval()

                 snake_case_   			=   self._prepare_for_class(lowerCAmelCase__,				lowerCAmelCase__)
                 snake_case_   			=   inputs['''input_ids'''].shape[0]
                 with torch.no_grad():
                      snake_case_   			=   model(**lowerCAmelCase__)

                 snake_case_   			=   1
                 self.assertEqual(out_len + added_hidden_states,				len(lowerCAmelCase__))

                 snake_case_   			=   outputs.attentions

                 self.assertEqual(len(lowerCAmelCase__),				self.model_tester.num_hidden_layers)
                 self.assertListEqual(
                     list(self_attentions[0].shape[-3:]),				[batch_size, seq_len, config.hidden_size],				)







       @slow
       def 						a_		(					self) -> str:
            for model_name in RWKV_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 snake_case_   			=   RwkvModel.from_pretrained(lowerCAmelCase__)
                 self.assertIsNotNone(lowerCAmelCase__)




@unittest.skipIf(
    not is_torch_greater_or_equal_than_2_0       ,						reason="See https://github.com/huggingface/transformers/pull/24204"  )
@slow
class 					UpperCamelCase   (							unittest.TestCase  ):







       def 						a_		(					self) -> Optional[int]:
            snake_case_   			=   '''RWKV/rwkv-4-169m-pile'''
            snake_case_   			=   AutoTokenizer.from_pretrained(self.model_id)







       def 						a_		(					self) -> str:
            snake_case_   			=   '''Hello my name is Jasmine and I am a newbie to the'''
            snake_case_   			=   RwkvForCausalLM.from_pretrained(self.model_id).to(lowerCAmelCase__)

            snake_case_   			=   self.tokenizer('Hello my name is',				return_tensors='pt').input_ids.to(lowerCAmelCase__)
            snake_case_   			=   model.generate(lowerCAmelCase__,				max_new_tokens=10)
            snake_case_   			=   self.tokenizer.decode(output[0].tolist())

            self.assertEqual(lowerCAmelCase__,				lowerCAmelCase__)







       def 						a_		(					self) -> List[str]:
            snake_case_   			=   '''Hello my name is Jasmine and I am a newbie to the'''

            snake_case_   			=   self.tokenizer('Hello my name is',				return_tensors='pt').input_ids.to(lowerCAmelCase__)
            snake_case_   			=   RwkvForCausalLM.from_pretrained(self.model_id,				torch_dtype=torch.bfloataa).to(lowerCAmelCase__)

            snake_case_   			=   model.generate(lowerCAmelCase__,				max_new_tokens=10)
            snake_case_   			=   self.tokenizer.decode(output[0].tolist())

            self.assertEqual(lowerCAmelCase__,				lowerCAmelCase__)








'''simple docstring'''







from manim import *


class        __a   (lowerCamelCase  ):

							def      UpperCAmelCase__						(				self				:  str )       ->							Any:







													"""simple docstring"""
													UpperCAmelCase_      :   List[str]      =	Rectangle(height=0.5							,  width=0.5 )
													UpperCAmelCase_      :   int      =	Rectangle(height=0.4_6							,  width=0.4_6 ).set_stroke(width=0 )
													UpperCAmelCase_      :   str      =	Rectangle(height=0.2_5							,  width=0.2_5 )

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

													UpperCAmelCase_      :   List[Any]      =	[mem.copy() for i in range(4 )]
													UpperCAmelCase_      :   List[str]      =	VGroup(*__magic_name__ ).arrange(__magic_name__							,  buff=0 )
													UpperCAmelCase_      :   str      =	Text('''GPU'''							,  font_size=24 )
													UpperCAmelCase_      :   Union[str, Any]      =	Group(__magic_name__							,  __magic_name__ ).arrange(__magic_name__							,  buff=0.5							,  aligned_edge=__magic_name__ )
													gpu.move_to([-1, -1, 0] )
													self.add(__magic_name__ )

													UpperCAmelCase_      :   Dict      =	[mem.copy() for i in range(6 )]
													UpperCAmelCase_      :   Optional[Any]      =	VGroup(*__magic_name__ ).arrange(__magic_name__							,  buff=0 )

													UpperCAmelCase_      :   Dict      =	Text('''Model'''							,  font_size=24 )
													UpperCAmelCase_      :   str      =	Group(__magic_name__							,  __magic_name__ ).arrange(__magic_name__							,  buff=0.5							,  aligned_edge=__magic_name__ )
													model.move_to([3, -1.0, 0] )
													self.add(__magic_name__ )

													UpperCAmelCase_      :   List[str]      =	[]
													UpperCAmelCase_      :   int      =	[]

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

																			UpperCAmelCase_      :   List[Any]      =	Rectangle(height=0.4_6 / 4							,  width=0.4_6 / 3 ).set_stroke(width=0.0 ).set_fill(__magic_name__							,  opacity=0.7 )

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

													self.add(*__magic_name__							,  *__magic_name__ )

													UpperCAmelCase_      :   Any      =	[meta_mem.copy() for i in range(6 )]
													UpperCAmelCase_      :   int      =	[meta_mem.copy() for i in range(6 )]
													UpperCAmelCase_      :   Optional[Any]      =	VGroup(*__magic_name__ ).arrange(__magic_name__							,  buff=0 )
													UpperCAmelCase_      :   Optional[int]      =	VGroup(*__magic_name__ ).arrange(__magic_name__							,  buff=0 )
													UpperCAmelCase_      :   Dict      =	VGroup(__magic_name__							,  __magic_name__ ).arrange(__magic_name__							,  buff=0 )
													UpperCAmelCase_      :   Optional[Any]      =	Text('''Disk'''							,  font_size=24 )
													UpperCAmelCase_      :   Any      =	Group(__magic_name__							,  __magic_name__ ).arrange(__magic_name__							,  buff=0.5							,  aligned_edge=__magic_name__ )
													disk.move_to([-4.0, -1.2_5, 0] )
													self.add(__magic_name__							,  __magic_name__ )

													UpperCAmelCase_      :   Optional[Any]      =	[]

													for i in range(6 ):
																			UpperCAmelCase_      :   Tuple      =	fill.copy().set_fill(__magic_name__							,  opacity=0.8 )
																			target.move_to(disk_left_col_base[i] ).scale(0.5 )
																			cpu_disk_arr.append(__magic_name__ )

													self.add(*__magic_name__ )

													UpperCAmelCase_      :   List[str]      =	Square(side_length=2.2 )
													key.move_to([-5, 2, 0] )

													UpperCAmelCase_      :   Union[str, 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(__magic_name__							,  __magic_name__ )

													UpperCAmelCase_      :   Union[str, Any]      =	MarkupText(
													    F"""<span fgcolor='{BLUE}'>●</span> Checkpoint"""							,  font_size=18							,  )

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

													UpperCAmelCase_      :   Dict      =	MarkupText(F"""The offloaded weights are all sent to the CPU."""							,  font_size=24 )
													step_a.move_to([2, 2, 0] )

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

													for i in range(6 ):
																			UpperCAmelCase_      :   Dict      =	cpu_disk_arr[i]
																			UpperCAmelCase_      :   int      =	rect.copy().set_fill(__magic_name__							,  opacity=0.8 ).scale(2.0 )
																			cpa.generate_target()
																			cpa.target.move_to(model_base[i] )

																			if i == 0:
																									rect.set_fill(__magic_name__							,  opacity=0.8 )
																									rect.generate_target()
																									rect.target.move_to(cpu_left_col_base[0] ).scale(2.0 )

																									self.remove(
																									    *__magic_name__							,  *__magic_name__							,  )

																			else:
																									rect.generate_target()
																									rect.target.move_to(cpu_left_col_base[i] ).scale(2.0 )
																			self.play(MoveToTarget(__magic_name__ )							,  MoveToTarget(__magic_name__ )							,  model_base[i].animate.set_stroke(__magic_name__ ) )
													self.play(FadeOut(__magic_name__ ) )

													UpperCAmelCase_      :   int      =	MarkupText(
													    F"""Finally, hooks are added to each weight in the model\nto transfer the weights from CPU to GPU\n\t\tand back when needed."""							,  font_size=24							,  )
													step_a.move_to([2, 2, 0] )

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

													UpperCAmelCase_      :   Union[str, Any]      =	[]
													UpperCAmelCase_      :   Tuple      =	[]
													for i in range(6 ):
																			UpperCAmelCase_      :   List[Any]      =	Arrow(start=__magic_name__							,  end=__magic_name__							,  color=__magic_name__							,  buff=0.5 )
																			a.next_to(model_base[i].get_left()							,  __magic_name__							,  buff=0.2 )
																			arrows.append(__magic_name__ )
																			animations.append(Write(__magic_name__ ) )
													self.play(*__magic_name__ )
													self.wait()





