
"""simple docstring"""




from typing import Optional

import torch
import torch.utils.checkpoint
from torch import Tensor, nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss

from ...activations import ACTaFN
from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
from ...modeling_outputs import (
    BaseModelOutputWithNoAttention,
    BaseModelOutputWithPoolingAndNoAttention,
    ImageClassifierOutputWithNoAttention,
)
from ...modeling_utils import PreTrainedModel
from ...utils import logging
from .configuration_regnet import RegNetConfig


UpperCAmelCase__   :					Optional[int]												=				logging.get_logger(__name__)

# General docstring
UpperCAmelCase__   :					Any												=				'RegNetConfig'

# Base docstring
UpperCAmelCase__   :					Any												=				'facebook/regnet-y-040'
UpperCAmelCase__   :					str												=				[1, 1_0_8_8, 7, 7]

# Image classification docstring
UpperCAmelCase__   :					Optional[int]												=				'facebook/regnet-y-040'
UpperCAmelCase__   :					Any												=				'tabby, tabby cat'

UpperCAmelCase__   :					Any												=				[
    'facebook/regnet-y-040',
    # See all regnet models at https://huggingface.co/models?filter=regnet
]



class 			lowerCAmelCase_		(nn.Module						):


    """simple docstring"""



    def __init__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__ = 3     , SCREAMING_SNAKE_CASE__ = 1     , SCREAMING_SNAKE_CASE__ = 1     , SCREAMING_SNAKE_CASE__ = "relu"     , )      ->	int:



           """simple docstring"""




           super().__init__()
           SCREAMING_SNAKE_CASE__		: Optional[Any]     =     nn.Convad(
               _SCREAMING_SNAKE_CASE     , _SCREAMING_SNAKE_CASE     , kernel_size=_SCREAMING_SNAKE_CASE     , stride=_SCREAMING_SNAKE_CASE     , padding=kernel_size // 2     , groups=_SCREAMING_SNAKE_CASE     , bias=_SCREAMING_SNAKE_CASE     , )
           SCREAMING_SNAKE_CASE__		: List[Any]     =     nn.BatchNormad(_SCREAMING_SNAKE_CASE					)
           SCREAMING_SNAKE_CASE__		: Optional[Any]     =     ACTaFN[activation] if activation is not None else nn.Identity()



    def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__					)      ->	Optional[int]:



           """simple docstring"""




           SCREAMING_SNAKE_CASE__		: Dict     =     self.convolution(_SCREAMING_SNAKE_CASE					)
           SCREAMING_SNAKE_CASE__		: str     =     self.normalization(_SCREAMING_SNAKE_CASE					)
           SCREAMING_SNAKE_CASE__		: int     =     self.activation(_SCREAMING_SNAKE_CASE					)
           return hidden_state






class 			lowerCAmelCase_		(nn.Module						):


    """simple docstring"""



    def __init__(self     , SCREAMING_SNAKE_CASE__					)      ->	Union[str, Any]:



           """simple docstring"""




           super().__init__()
           SCREAMING_SNAKE_CASE__		: Optional[Any]     =     RegNetConvLayer(
               config.num_channels     , config.embedding_size     , kernel_size=3     , stride=2     , activation=config.hidden_act					)
           SCREAMING_SNAKE_CASE__		: Any     =     config.num_channels



    def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__					)      ->	List[Any]:



           """simple docstring"""




           SCREAMING_SNAKE_CASE__		: Any     =     pixel_values.shape[1]
           if num_channels != self.num_channels:
                  raise ValueError(
                      """Make sure that the channel dimension of the pixel values match with the one set in the configuration."""					)
           SCREAMING_SNAKE_CASE__		: Tuple     =     self.embedder(_SCREAMING_SNAKE_CASE					)
           return hidden_state






class 			lowerCAmelCase_		(nn.Module						):


    """simple docstring"""



    def __init__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__ = 2					)      ->	Dict:



           """simple docstring"""




           super().__init__()
           SCREAMING_SNAKE_CASE__		: Any     =     nn.Convad(_SCREAMING_SNAKE_CASE     , _SCREAMING_SNAKE_CASE     , kernel_size=1     , stride=_SCREAMING_SNAKE_CASE     , bias=_SCREAMING_SNAKE_CASE					)
           SCREAMING_SNAKE_CASE__		: int     =     nn.BatchNormad(_SCREAMING_SNAKE_CASE					)



    def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__					)      ->	Tensor:



           """simple docstring"""




           SCREAMING_SNAKE_CASE__		: Optional[Any]     =     self.convolution(_SCREAMING_SNAKE_CASE					)
           SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     self.normalization(_SCREAMING_SNAKE_CASE					)
           return hidden_state






class 			lowerCAmelCase_		(nn.Module						):


    """simple docstring"""



    def __init__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	Dict:



           """simple docstring"""




           super().__init__()

           SCREAMING_SNAKE_CASE__		: str     =     nn.AdaptiveAvgPoolad((1, 1)					)
           SCREAMING_SNAKE_CASE__		: Any     =     nn.Sequential(
               nn.Convad(_SCREAMING_SNAKE_CASE     , _SCREAMING_SNAKE_CASE     , kernel_size=1					)     , nn.ReLU()     , nn.Convad(_SCREAMING_SNAKE_CASE     , _SCREAMING_SNAKE_CASE     , kernel_size=1					)     , nn.Sigmoid()     , )



    def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__					)      ->	Optional[Any]:



           """simple docstring"""




           SCREAMING_SNAKE_CASE__		: int     =     self.pooler(_SCREAMING_SNAKE_CASE					)
           SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     self.attention(_SCREAMING_SNAKE_CASE					)
           SCREAMING_SNAKE_CASE__		: Optional[int]     =     hidden_state * attention
           return hidden_state






class 			lowerCAmelCase_		(nn.Module						):


    """simple docstring"""



    def __init__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__ = 1					)      ->	Tuple:



           """simple docstring"""




           super().__init__()
           SCREAMING_SNAKE_CASE__		: Any     =     in_channels != out_channels or stride != 1
           SCREAMING_SNAKE_CASE__		: Tuple     =     max(1     , out_channels // config.groups_width					)
           SCREAMING_SNAKE_CASE__		: Any     =     (
               RegNetShortCut(_SCREAMING_SNAKE_CASE     , _SCREAMING_SNAKE_CASE     , stride=_SCREAMING_SNAKE_CASE					) if should_apply_shortcut else nn.Identity()
           )
           SCREAMING_SNAKE_CASE__		: Any     =     nn.Sequential(
               RegNetConvLayer(_SCREAMING_SNAKE_CASE     , _SCREAMING_SNAKE_CASE     , kernel_size=1     , activation=config.hidden_act					)     , RegNetConvLayer(_SCREAMING_SNAKE_CASE     , _SCREAMING_SNAKE_CASE     , stride=_SCREAMING_SNAKE_CASE     , groups=_SCREAMING_SNAKE_CASE     , activation=config.hidden_act					)     , RegNetConvLayer(_SCREAMING_SNAKE_CASE     , _SCREAMING_SNAKE_CASE     , kernel_size=1     , activation=_SCREAMING_SNAKE_CASE					)     , )
           SCREAMING_SNAKE_CASE__		: List[Any]     =     ACTaFN[config.hidden_act]



    def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__					)      ->	Tuple:



           """simple docstring"""




           SCREAMING_SNAKE_CASE__		: str     =     hidden_state
           SCREAMING_SNAKE_CASE__		: List[Any]     =     self.layer(_SCREAMING_SNAKE_CASE					)
           SCREAMING_SNAKE_CASE__		: Optional[Any]     =     self.shortcut(_SCREAMING_SNAKE_CASE					)
           hidden_state += residual
           SCREAMING_SNAKE_CASE__		: List[str]     =     self.activation(_SCREAMING_SNAKE_CASE					)
           return hidden_state






class 			lowerCAmelCase_		(nn.Module						):


    """simple docstring"""



    def __init__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__ = 1					)      ->	Dict:



           """simple docstring"""




           super().__init__()
           SCREAMING_SNAKE_CASE__		: str     =     in_channels != out_channels or stride != 1
           SCREAMING_SNAKE_CASE__		: Optional[Any]     =     max(1     , out_channels // config.groups_width					)
           SCREAMING_SNAKE_CASE__		: Optional[int]     =     (
               RegNetShortCut(_SCREAMING_SNAKE_CASE     , _SCREAMING_SNAKE_CASE     , stride=_SCREAMING_SNAKE_CASE					) if should_apply_shortcut else nn.Identity()
           )
           SCREAMING_SNAKE_CASE__		: int     =     nn.Sequential(
               RegNetConvLayer(_SCREAMING_SNAKE_CASE     , _SCREAMING_SNAKE_CASE     , kernel_size=1     , activation=config.hidden_act					)     , RegNetConvLayer(_SCREAMING_SNAKE_CASE     , _SCREAMING_SNAKE_CASE     , stride=_SCREAMING_SNAKE_CASE     , groups=_SCREAMING_SNAKE_CASE     , activation=config.hidden_act					)     , RegNetSELayer(_SCREAMING_SNAKE_CASE     , reduced_channels=int(round(in_channels / 4					)					)					)     , RegNetConvLayer(_SCREAMING_SNAKE_CASE     , _SCREAMING_SNAKE_CASE     , kernel_size=1     , activation=_SCREAMING_SNAKE_CASE					)     , )
           SCREAMING_SNAKE_CASE__		: int     =     ACTaFN[config.hidden_act]



    def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__					)      ->	Union[str, Any]:



           """simple docstring"""




           SCREAMING_SNAKE_CASE__		: Any     =     hidden_state
           SCREAMING_SNAKE_CASE__		: Tuple     =     self.layer(_SCREAMING_SNAKE_CASE					)
           SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     self.shortcut(_SCREAMING_SNAKE_CASE					)
           hidden_state += residual
           SCREAMING_SNAKE_CASE__		: str     =     self.activation(_SCREAMING_SNAKE_CASE					)
           return hidden_state






class 			lowerCAmelCase_		(nn.Module						):


    """simple docstring"""



    def __init__(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__ = 2     , SCREAMING_SNAKE_CASE__ = 2     , )      ->	Optional[int]:



           """simple docstring"""




           super().__init__()

           SCREAMING_SNAKE_CASE__		: List[str]     =     RegNetXLayer if config.layer_type == """x""" else RegNetYLayer

           SCREAMING_SNAKE_CASE__		: Any     =     nn.Sequential(
               # downsampling is done in the first layer with stride of 2
               layer(
                   _SCREAMING_SNAKE_CASE     , _SCREAMING_SNAKE_CASE     , _SCREAMING_SNAKE_CASE     , stride=_SCREAMING_SNAKE_CASE     , )     , *[layer(_SCREAMING_SNAKE_CASE     , _SCREAMING_SNAKE_CASE     , _SCREAMING_SNAKE_CASE					) for _ in range(depth - 1					)]     , )



    def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__					)      ->	Any:



           """simple docstring"""




           SCREAMING_SNAKE_CASE__		: int     =     self.layers(_SCREAMING_SNAKE_CASE					)
           return hidden_state






class 			lowerCAmelCase_		(nn.Module						):


    """simple docstring"""



    def __init__(self     , SCREAMING_SNAKE_CASE__					)      ->	Dict:



           """simple docstring"""




           super().__init__()
           SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     nn.ModuleList([]					)
           # based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input
           self.stages.append(
               RegNetStage(
                   _SCREAMING_SNAKE_CASE     , config.embedding_size     , config.hidden_sizes[0]     , stride=2 if config.downsample_in_first_stage else 1     , depth=config.depths[0]     , )					)
           SCREAMING_SNAKE_CASE__		: Tuple     =     zip(config.hidden_sizes     , config.hidden_sizes[1:]					)
           for (in_channels, out_channels), depth in zip(_SCREAMING_SNAKE_CASE     , config.depths[1:]					):
                  self.stages.append(RegNetStage(_SCREAMING_SNAKE_CASE     , _SCREAMING_SNAKE_CASE     , _SCREAMING_SNAKE_CASE     , depth=_SCREAMING_SNAKE_CASE					)					)



    def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__ = False     , SCREAMING_SNAKE_CASE__ = True					)      ->	BaseModelOutputWithNoAttention:



           """simple docstring"""




           SCREAMING_SNAKE_CASE__		: str     =     () if output_hidden_states else None

           for stage_module in self.stages:
                  if output_hidden_states:
                         SCREAMING_SNAKE_CASE__		: Dict     =     hidden_states + (hidden_state,)

                  SCREAMING_SNAKE_CASE__		: List[str]     =     stage_module(_SCREAMING_SNAKE_CASE					)

           if output_hidden_states:
                  SCREAMING_SNAKE_CASE__		: str     =     hidden_states + (hidden_state,)

           if not return_dict:
                  return tuple(v for v in [hidden_state, hidden_states] if v is not None					)

           return BaseModelOutputWithNoAttention(last_hidden_state=_SCREAMING_SNAKE_CASE     , hidden_states=_SCREAMING_SNAKE_CASE					)






class 			lowerCAmelCase_		(lowerCAmelCase__						):


    """simple docstring"""



    __UpperCamelCase   :		Any       =     RegNetConfig
    __UpperCamelCase   :		List[str]       =     "regnet"
    __UpperCamelCase   :		Optional[int]       =     "pixel_values"
    __UpperCamelCase   :		Tuple       =     True



    def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__					)      ->	Any:



           """simple docstring"""




           if isinstance(_SCREAMING_SNAKE_CASE     , nn.Convad					):
                  nn.init.kaiming_normal_(module.weight     , mode="""fan_out"""     , nonlinearity="""relu"""					)
           elif isinstance(_SCREAMING_SNAKE_CASE     , (nn.BatchNormad, nn.GroupNorm)					):
                  nn.init.constant_(module.weight     , 1					)
                  nn.init.constant_(module.bias     , 0					)



    def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__=False					)      ->	Tuple:



           """simple docstring"""




           if isinstance(_SCREAMING_SNAKE_CASE     , _SCREAMING_SNAKE_CASE					):
                  SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     value






UpperCAmelCase__   :					List[str]												=				R'\n    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) subclass. Use it\n    as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and\n    behavior.\n\n    Parameters:\n        config ([`RegNetConfig`]): Model configuration class with all the parameters of the model.\n            Initializing with a config file does not load the weights associated with the model, only the\n            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.\n'

UpperCAmelCase__   :					Optional[Any]												=				R'\n    Args:\n        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):\n            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See\n            [`ConvNextImageProcessor.__call__`] for details.\n\n        output_hidden_states (`bool`, *optional*):\n            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for\n            more detail.\n        return_dict (`bool`, *optional*):\n            Whether or not to return a [`~file_utils.ModelOutput`] instead of a plain tuple.\n'



@add_start_docstrings(
    '''The bare RegNet model outputting raw features without any specific head on top.'''				,      lowerCAmelCase__				,      )
# Copied from transformers.models.resnet.modeling_resnet.ResNetModel with RESNET->REGNET,ResNet->RegNet
class 			lowerCAmelCase_		(lowerCAmelCase__						):


    """simple docstring"""



    def __init__(self     , SCREAMING_SNAKE_CASE__					)      ->	List[Any]:



           """simple docstring"""




           super().__init__(_SCREAMING_SNAKE_CASE					)
           SCREAMING_SNAKE_CASE__		: Tuple     =     config
           SCREAMING_SNAKE_CASE__		: str     =     RegNetEmbeddings(_SCREAMING_SNAKE_CASE					)
           SCREAMING_SNAKE_CASE__		: Optional[int]     =     RegNetEncoder(_SCREAMING_SNAKE_CASE					)
           SCREAMING_SNAKE_CASE__		: Any     =     nn.AdaptiveAvgPoolad((1, 1)					)
           # Initialize weights and apply final processing
           self.post_init()



    @add_start_docstrings_to_model_forward(_SCREAMING_SNAKE_CASE					)
    @add_code_sample_docstrings(
        checkpoint=_CHECKPOINT_FOR_DOC     , output_type=_SCREAMING_SNAKE_CASE     , config_class=_CONFIG_FOR_DOC     , modality="""vision"""     , expected_output=_EXPECTED_OUTPUT_SHAPE     , )
    def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__ = None     , SCREAMING_SNAKE_CASE__ = None					)      ->	BaseModelOutputWithPoolingAndNoAttention:



           """simple docstring"""




           SCREAMING_SNAKE_CASE__		: Any     =     (
               output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
           )
           SCREAMING_SNAKE_CASE__		: Any     =     return_dict if return_dict is not None else self.config.use_return_dict

           SCREAMING_SNAKE_CASE__		: int     =     self.embedder(_SCREAMING_SNAKE_CASE					)

           SCREAMING_SNAKE_CASE__		: List[str]     =     self.encoder(
               _SCREAMING_SNAKE_CASE     , output_hidden_states=_SCREAMING_SNAKE_CASE     , return_dict=_SCREAMING_SNAKE_CASE					)

           SCREAMING_SNAKE_CASE__		: Optional[Any]     =     encoder_outputs[0]

           SCREAMING_SNAKE_CASE__		: Optional[Any]     =     self.pooler(_SCREAMING_SNAKE_CASE					)

           if not return_dict:
                  return (last_hidden_state, pooled_output) + encoder_outputs[1:]

           return BaseModelOutputWithPoolingAndNoAttention(
               last_hidden_state=_SCREAMING_SNAKE_CASE     , pooler_output=_SCREAMING_SNAKE_CASE     , hidden_states=encoder_outputs.hidden_states     , )






@add_start_docstrings(
    '''\n    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    '''				,      lowerCAmelCase__				,      )
# Copied from transformers.models.resnet.modeling_resnet.ResNetForImageClassification with RESNET->REGNET,ResNet->RegNet,resnet->regnet
class 			lowerCAmelCase_		(lowerCAmelCase__						):


    """simple docstring"""



    def __init__(self     , SCREAMING_SNAKE_CASE__					)      ->	List[str]:



           """simple docstring"""




           super().__init__(_SCREAMING_SNAKE_CASE					)
           SCREAMING_SNAKE_CASE__		: Optional[Any]     =     config.num_labels
           SCREAMING_SNAKE_CASE__		: int     =     RegNetModel(_SCREAMING_SNAKE_CASE					)
           # classification head
           SCREAMING_SNAKE_CASE__		: Optional[int]     =     nn.Sequential(
               nn.Flatten()     , nn.Linear(config.hidden_sizes[-1]     , config.num_labels					) if config.num_labels > 0 else nn.Identity()     , )
           # initialize weights and apply final processing
           self.post_init()



    @add_start_docstrings_to_model_forward(_SCREAMING_SNAKE_CASE					)
    @add_code_sample_docstrings(
        checkpoint=_IMAGE_CLASS_CHECKPOINT     , output_type=_SCREAMING_SNAKE_CASE     , config_class=_CONFIG_FOR_DOC     , expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT     , )
    def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__ = None     , SCREAMING_SNAKE_CASE__ = None     , SCREAMING_SNAKE_CASE__ = None     , SCREAMING_SNAKE_CASE__ = None     , )      ->	ImageClassifierOutputWithNoAttention:



           """simple docstring"""




           SCREAMING_SNAKE_CASE__		: List[str]     =     return_dict if return_dict is not None else self.config.use_return_dict

           SCREAMING_SNAKE_CASE__		: List[str]     =     self.regnet(_SCREAMING_SNAKE_CASE     , output_hidden_states=_SCREAMING_SNAKE_CASE     , return_dict=_SCREAMING_SNAKE_CASE					)

           SCREAMING_SNAKE_CASE__		: Dict     =     outputs.pooler_output if return_dict else outputs[1]

           SCREAMING_SNAKE_CASE__		: Any     =     self.classifier(_SCREAMING_SNAKE_CASE					)

           SCREAMING_SNAKE_CASE__		: Optional[Any]     =     None

           if labels is not None:
                  if self.config.problem_type is None:
                         if self.num_labels == 1:
                                SCREAMING_SNAKE_CASE__		: Optional[int]     =     """regression"""
                         elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
                                SCREAMING_SNAKE_CASE__		: List[str]     =     """single_label_classification"""
                         else:
                                SCREAMING_SNAKE_CASE__		: str     =     """multi_label_classification"""
                  if self.config.problem_type == "regression":
                         SCREAMING_SNAKE_CASE__		: List[str]     =     MSELoss()
                         if self.num_labels == 1:
                                SCREAMING_SNAKE_CASE__		: Optional[Any]     =     loss_fct(logits.squeeze()     , labels.squeeze()					)
                         else:
                                SCREAMING_SNAKE_CASE__		: Optional[int]     =     loss_fct(_SCREAMING_SNAKE_CASE     , _SCREAMING_SNAKE_CASE					)
                  elif self.config.problem_type == "single_label_classification":
                         SCREAMING_SNAKE_CASE__		: List[Any]     =     CrossEntropyLoss()
                         SCREAMING_SNAKE_CASE__		: Optional[Any]     =     loss_fct(logits.view(-1     , self.num_labels					)     , labels.view(-1					)					)
                  elif self.config.problem_type == "multi_label_classification":
                         SCREAMING_SNAKE_CASE__		: List[Any]     =     BCEWithLogitsLoss()
                         SCREAMING_SNAKE_CASE__		: List[Any]     =     loss_fct(_SCREAMING_SNAKE_CASE     , _SCREAMING_SNAKE_CASE					)

           if not return_dict:
                  SCREAMING_SNAKE_CASE__		: List[Any]     =     (logits,) + outputs[2:]
                  return (loss,) + output if loss is not None else output

           return ImageClassifierOutputWithNoAttention(loss=_SCREAMING_SNAKE_CASE     , logits=_SCREAMING_SNAKE_CASE     , hidden_states=outputs.hidden_states					)






"""simple docstring"""




from manim import *



class 			lowerCAmelCase_		(a__						):


				"""simple docstring"""



				def 			__magic_name__					(self					)      ->	List[str]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Dict     =     Rectangle(height=0.5     , width=0.5					)
											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     Rectangle(height=0.46     , width=0.46					).set_stroke(width=0					)

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

											SCREAMING_SNAKE_CASE__		: Optional[int]     =     [mem.copy() for i in range(1					)]
											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     VGroup(*SCREAMING_SNAKE_CASE__					).arrange(SCREAMING_SNAKE_CASE__     , buff=0					)
											SCREAMING_SNAKE_CASE__		: str     =     Text("""GPU"""     , font_size=24					)
											SCREAMING_SNAKE_CASE__		: str     =     Group(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					).arrange(SCREAMING_SNAKE_CASE__     , buff=0.5     , aligned_edge=SCREAMING_SNAKE_CASE__					)
											gpu.align_to(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)
											gpu.set_x(gpu.get_x() - 1					)

											self.add(SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: List[Any]     =     [mem.copy() for i in range(6					)]
											SCREAMING_SNAKE_CASE__		: List[Any]     =     VGroup(*SCREAMING_SNAKE_CASE__					).arrange(SCREAMING_SNAKE_CASE__     , buff=0					)

											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     Text("""Model"""     , font_size=24					)
											SCREAMING_SNAKE_CASE__		: Any     =     Group(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					).arrange(SCREAMING_SNAKE_CASE__     , buff=0.5     , aligned_edge=SCREAMING_SNAKE_CASE__					)
											model.move_to([3, -1.0, 0]					)

											self.play(
											    Create(SCREAMING_SNAKE_CASE__     , run_time=1					)     , Create(SCREAMING_SNAKE_CASE__     , run_time=1					)     , Create(SCREAMING_SNAKE_CASE__     , run_time=1					)     , )

											SCREAMING_SNAKE_CASE__		: Tuple     =     MarkupText(
											    F'''First, an empty model skeleton is loaded\ninto <span fgcolor=\'{YELLOW}\'>memory</span> without using much RAM.'''     , font_size=24     , )

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

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

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

											step_a.move_to([2, 2, 0]					)
											self.play(Write(SCREAMING_SNAKE_CASE__     , run_time=2.5					)     , Write(SCREAMING_SNAKE_CASE__					)     , Write(SCREAMING_SNAKE_CASE__					)					)

											self.add(SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: Optional[int]     =     []
											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     []
											SCREAMING_SNAKE_CASE__		: str     =     []
											for i, rect in enumerate(SCREAMING_SNAKE_CASE__					):
																		SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     Rectangle(height=0.46     , width=0.46					).set_stroke(width=0.0					).set_fill(SCREAMING_SNAKE_CASE__     , opacity=0.7					)
																		cpu_target.move_to(SCREAMING_SNAKE_CASE__					)
																		cpu_target.generate_target()
																		SCREAMING_SNAKE_CASE__		: Tuple     =     0.46 / 4
																		SCREAMING_SNAKE_CASE__		: int     =     0.46 / 3

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

																		first_animations.append(rect.animate(run_time=0.5					).set_stroke(SCREAMING_SNAKE_CASE__					)					)
																		second_animations.append(MoveToTarget(SCREAMING_SNAKE_CASE__     , run_time=1.5					)					)

											self.play(*SCREAMING_SNAKE_CASE__					)
											self.play(*SCREAMING_SNAKE_CASE__					)

											self.wait()




