

"""simple docstring"""



import os
import unittest
from tempfile import TemporaryDirectory

import torch
import torch.nn as nn

from accelerate.utils import (
    OffloadedWeightsLoader,
    extract_submodules_state_dict,
    load_offloaded_weight,
    offload_state_dict,
    offload_weight,
)



class 					a						(       nn.Module				):



    """simple docstring"""



    def __init__(     self: int       ):






         """simple docstring"""


         super().__init__()
         A__										=  nn.Linear(3    ,						4       )
         A__										=  nn.BatchNormad(4       )
         A__										=  nn.Linear(4    ,						5       )





    def 				UpperCamelCase	(     self: Union[str, Any]    ,						UpperCamelCase: List[Any]       ):






         """simple docstring"""


         return self.lineara(self.batchnorm(self.lineara(UpperCamelCase       )       )       )



class 					a						(       unittest.TestCase				):



    """simple docstring"""



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






         """simple docstring"""


         A__										=  ModelForTest()
         with TemporaryDirectory() as tmp_dir:
              offload_state_dict(UpperCamelCase    ,						model.state_dict()       )
              A__										=  os.path.join(UpperCamelCase    ,						"""index.json"""       )
              self.assertTrue(os.path.isfile(UpperCamelCase       )       )
              # TODO: add tests on what is inside the index

              for key in ["linear1.weight", "linear1.bias", "linear2.weight", "linear2.bias"]:
                   A__										=  os.path.join(UpperCamelCase    ,						f"""{key}.dat"""       )
                   self.assertTrue(os.path.isfile(UpperCamelCase       )       )
                   # TODO: add tests on the fact weights are properly loaded

    def 				UpperCamelCase	(     self: Optional[int]       ):






         """simple docstring"""


         A__										=  [torch.floataa, torch.floataa, torch.bfloataa]

         for dtype in dtypes:
              A__										=  torch.randn(2    ,						3    ,						dtype=UpperCamelCase       )
              with TemporaryDirectory() as tmp_dir:
                   A__										=  offload_weight(UpperCamelCase    ,						"""weight"""    ,						UpperCamelCase    ,						{}       )
                   A__										=  os.path.join(UpperCamelCase    ,						"""weight.dat"""       )
                   self.assertTrue(os.path.isfile(UpperCamelCase       )       )
                   self.assertDictEqual(UpperCamelCase    ,						{"""weight""": {"""shape""": [2, 3], """dtype""": str(UpperCamelCase       ).split("""."""       )[1]}}       )

                   A__										=  load_offloaded_weight(UpperCamelCase    ,						index["""weight"""]       )
                   self.assertTrue(torch.equal(UpperCamelCase    ,						UpperCamelCase       )       )

    def 				UpperCamelCase	(     self: Optional[int]       ):






         """simple docstring"""


         A__										=  ModelForTest()
         A__										=  model.state_dict()
         A__										=  {k: v for k, v in state_dict.items() if """linear2""" not in k}
         A__										=  {k: v for k, v in state_dict.items() if """linear2""" in k}

         with TemporaryDirectory() as tmp_dir:
              offload_state_dict(UpperCamelCase    ,						UpperCamelCase       )
              A__										=  OffloadedWeightsLoader(state_dict=UpperCamelCase    ,						save_folder=UpperCamelCase       )

              # Every key is there with the right value
              self.assertEqual(sorted(UpperCamelCase       )    ,						sorted(state_dict.keys()       )       )
              for key, param in state_dict.items():
                   self.assertTrue(torch.allclose(UpperCamelCase    ,						weight_map[key]       )       )

         A__										=  {k: v for k, v in state_dict.items() if """weight""" in k}
         A__										=  {k: v for k, v in state_dict.items() if """weight""" not in k}

         with TemporaryDirectory() as tmp_dir:
              offload_state_dict(UpperCamelCase    ,						UpperCamelCase       )
              A__										=  OffloadedWeightsLoader(state_dict=UpperCamelCase    ,						save_folder=UpperCamelCase       )

              # Every key is there with the right value
              self.assertEqual(sorted(UpperCamelCase       )    ,						sorted(state_dict.keys()       )       )
              for key, param in state_dict.items():
                   self.assertTrue(torch.allclose(UpperCamelCase    ,						weight_map[key]       )       )

         with TemporaryDirectory() as tmp_dir:
              offload_state_dict(UpperCamelCase    ,						UpperCamelCase       )
              # Duplicates are removed
              A__										=  OffloadedWeightsLoader(state_dict=UpperCamelCase    ,						save_folder=UpperCamelCase       )

              # Every key is there with the right value
              self.assertEqual(sorted(UpperCamelCase       )    ,						sorted(state_dict.keys()       )       )
              for key, param in state_dict.items():
                   self.assertTrue(torch.allclose(UpperCamelCase    ,						weight_map[key]       )       )





    def 				UpperCamelCase	(     self: str       ):






         """simple docstring"""


         A__										=  {"""a.1""": 0, """a.10""": 1, """a.2""": 2}
         A__										=  extract_submodules_state_dict(UpperCamelCase    ,						["""a.1""", """a.2"""]       )
         self.assertDictEqual(UpperCamelCase    ,						{"""a.1""": 0, """a.2""": 2}       )

         A__										=  {"""a.1.a""": 0, """a.10.a""": 1, """a.2.a""": 2}
         A__										=  extract_submodules_state_dict(UpperCamelCase    ,						["""a.1""", """a.2"""]       )
         self.assertDictEqual(UpperCamelCase    ,						{"""a.1.a""": 0, """a.2.a""": 2}       )









"""simple docstring"""



import warnings
from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


SCREAMING_SNAKE_CASE_					:	Any							  =						logging.get_logger(__name__)

SCREAMING_SNAKE_CASE_					:	Optional[Any]							  =						{
    'nvidia/segformer-b0-finetuned-ade-512-512': (
        'https://huggingface.co/nvidia/segformer-b0-finetuned-ade-512-512/resolve/main/config.json'
    ),
    # See all SegFormer models at https://huggingface.co/models?filter=segformer
}



class 					a						(       _lowerCamelCase				):



    """simple docstring"""



    UpperCAmelCase						 =					"segformer"

    def __init__(     self: Optional[Any]    ,						UpperCamelCase: Union[str, Any]=3    ,						UpperCamelCase: int=4    ,						UpperCamelCase: int=[2, 2, 2, 2]    ,						UpperCamelCase: List[str]=[8, 4, 2, 1]    ,						UpperCamelCase: List[Any]=[32, 64, 1_60, 2_56]    ,						UpperCamelCase: Any=[7, 3, 3, 3]    ,						UpperCamelCase: Union[str, Any]=[4, 2, 2, 2]    ,						UpperCamelCase: Tuple=[1, 2, 5, 8]    ,						UpperCamelCase: Optional[int]=[4, 4, 4, 4]    ,						UpperCamelCase: Dict="gelu"    ,						UpperCamelCase: Optional[Any]=0.0    ,						UpperCamelCase: List[str]=0.0    ,						UpperCamelCase: Union[str, Any]=0.1    ,						UpperCamelCase: List[Any]=0.02    ,						UpperCamelCase: int=0.1    ,						UpperCamelCase: Optional[int]=1e-6    ,						UpperCamelCase: int=2_56    ,						UpperCamelCase: Union[str, Any]=2_55    ,						**UpperCamelCase: Optional[Any]    ,						):






         """simple docstring"""


         super().__init__(**UpperCamelCase       )

         if "reshape_last_stage" in kwargs and kwargs["reshape_last_stage"] is False:
              warnings.warn(
                  """Reshape_last_stage is set to False in this config. This argument is deprecated and will soon be"""
                  """ removed, as the behaviour will default to that of reshape_last_stage = True."""    ,						UpperCamelCase    ,						)

         A__										=  num_channels
         A__										=  num_encoder_blocks
         A__										=  depths
         A__										=  sr_ratios
         A__										=  hidden_sizes
         A__										=  patch_sizes
         A__										=  strides
         A__										=  mlp_ratios
         A__										=  num_attention_heads
         A__										=  hidden_act
         A__										=  hidden_dropout_prob
         A__										=  attention_probs_dropout_prob
         A__										=  classifier_dropout_prob
         A__										=  initializer_range
         A__										=  drop_path_rate
         A__										=  layer_norm_eps
         A__										=  decoder_hidden_size
         A__										=  kwargs.get("""reshape_last_stage"""    ,						UpperCamelCase       )
         A__										=  semantic_loss_ignore_index



class 					a						(       _lowerCamelCase				):



    """simple docstring"""



    UpperCAmelCase						 =					version.parse("1.11"				)

    @property
    def 				UpperCamelCase	(     self: List[str]       ):






         """simple docstring"""


         return OrderedDict(
             [
                 ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
             ]       )

    @property
    def 				UpperCamelCase	(     self: int       ):






         """simple docstring"""


         return 1e-4





    @property
    def 				UpperCamelCase	(     self: Optional[int]       ):






         """simple docstring"""


         return 12






