






import collections
import inspect
import unittest

from transformers import FocalNetConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch
   from torch import nn

   from transformers import (
       FocalNetBackbone,
       FocalNetForImageClassification,
       FocalNetForMaskedImageModeling,
       FocalNetModel,
   )
   from transformers.models.focalnet.modeling_focalnet import FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
   from PIL import Image

   from transformers import AutoImageProcessor


class  SCREAMING_SNAKE_CASE			:
     '''simple docstring'''


     def __init__(				self       :	List[Any]					, UpperCAmelCase_       :	List[str]					, UpperCAmelCase_       :	Dict=13					, UpperCAmelCase_       :	str=32					, UpperCAmelCase_       :	int=2					, UpperCAmelCase_       :	Dict=3					, UpperCAmelCase_       :	Optional[int]=16					, UpperCAmelCase_       :	Optional[int]=[32, 64, 128]					, UpperCAmelCase_       :	str=[1, 2, 1]					, UpperCAmelCase_       :	Any=[2, 2, 4]					, UpperCAmelCase_       :	int=2					, UpperCAmelCase_       :	int=2.0					, UpperCAmelCase_       :	Dict=True					, UpperCAmelCase_       :	int=0.0					, UpperCAmelCase_       :	int=0.0					, UpperCAmelCase_       :	Dict=0.1					, UpperCAmelCase_       :	Union[str, Any]="gelu"					, UpperCAmelCase_       :	int=False					, UpperCAmelCase_       :	str=True					, UpperCAmelCase_       :	Union[str, Any]=0.02					, UpperCAmelCase_       :	List[str]=1E-5					, UpperCAmelCase_       :	str=True					, UpperCAmelCase_       :	List[str]=None					, UpperCAmelCase_       :	Union[str, Any]=True					, UpperCAmelCase_       :	Optional[int]=10					, UpperCAmelCase_       :	Optional[int]=8					, UpperCAmelCase_       :	Optional[int]=["stage1", "stage2"]					, UpperCAmelCase_       :	Dict=[1, 2]					, ):
       SCREAMING_SNAKE_CASE       :      str							=    parent
       SCREAMING_SNAKE_CASE       :      List[Any]							=    batch_size
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    image_size
       SCREAMING_SNAKE_CASE       :      List[Any]							=    patch_size
       SCREAMING_SNAKE_CASE       :      Tuple							=    num_channels
       SCREAMING_SNAKE_CASE       :      Dict							=    embed_dim
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    hidden_sizes
       SCREAMING_SNAKE_CASE       :      Dict							=    depths
       SCREAMING_SNAKE_CASE       :      Tuple							=    num_heads
       SCREAMING_SNAKE_CASE       :      str							=    window_size
       SCREAMING_SNAKE_CASE       :      Tuple							=    mlp_ratio
       SCREAMING_SNAKE_CASE       :      Tuple							=    qkv_bias
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    hidden_dropout_prob
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    attention_probs_dropout_prob
       SCREAMING_SNAKE_CASE       :      int							=    drop_path_rate
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    hidden_act
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    use_absolute_embeddings
       SCREAMING_SNAKE_CASE       :      Any							=    patch_norm
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    layer_norm_eps
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    initializer_range
       SCREAMING_SNAKE_CASE       :      List[str]							=    is_training
       SCREAMING_SNAKE_CASE       :      List[Any]							=    scope
       SCREAMING_SNAKE_CASE       :      List[str]							=    use_labels
       SCREAMING_SNAKE_CASE       :      List[str]							=    type_sequence_label_size
       SCREAMING_SNAKE_CASE       :      Tuple							=    encoder_stride
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    out_features
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    out_indices


     def 				_A       (				self       :	Tuple      ):
       SCREAMING_SNAKE_CASE       :      int							=    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]      )

       SCREAMING_SNAKE_CASE       :      Tuple							=    None
       if self.use_labels:
         SCREAMING_SNAKE_CASE       :      Dict							=    ids_tensor([self.batch_size]					, self.type_sequence_label_size      )

       SCREAMING_SNAKE_CASE       :      Tuple							=    self.get_config()

       return config, pixel_values, labels


     def 				_A       (				self       :	Optional[int]      ):
       return FocalNetConfig(
           image_size=self.image_size					, patch_size=self.patch_size					, num_channels=self.num_channels					, embed_dim=self.embed_dim					, hidden_sizes=self.hidden_sizes					, depths=self.depths					, num_heads=self.num_heads					, window_size=self.window_size					, mlp_ratio=self.mlp_ratio					, qkv_bias=self.qkv_bias					, hidden_dropout_prob=self.hidden_dropout_prob					, attention_probs_dropout_prob=self.attention_probs_dropout_prob					, drop_path_rate=self.drop_path_rate					, hidden_act=self.hidden_act					, use_absolute_embeddings=self.use_absolute_embeddings					, path_norm=self.patch_norm					, layer_norm_eps=self.layer_norm_eps					, initializer_range=self.initializer_range					, encoder_stride=self.encoder_stride					, out_features=self.out_features					, out_indices=self.out_indices					, )


     def 				_A       (				self       :	int					, UpperCAmelCase_       :	Union[str, Any]					, UpperCAmelCase_       :	Tuple					, UpperCAmelCase_       :	Dict      ):
       SCREAMING_SNAKE_CASE       :      Dict							=    FocalNetModel(config=UpperCAmelCase_      )
       model.to(UpperCAmelCase_      )
       model.eval()
       SCREAMING_SNAKE_CASE       :      List[Any]							=    model(UpperCAmelCase_      )

       SCREAMING_SNAKE_CASE       :      Tuple							=    ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths      ) - 1))
       SCREAMING_SNAKE_CASE       :      List[str]							=    int(config.embed_dim * 2 ** (len(config.depths      ) - 1)      )

       self.parent.assertEqual(result.last_hidden_state.shape					, (self.batch_size, expected_seq_len, expected_dim)      )


     def 				_A       (				self       :	int					, UpperCAmelCase_       :	Union[str, Any]					, UpperCAmelCase_       :	Dict					, UpperCAmelCase_       :	Optional[int]      ):
       SCREAMING_SNAKE_CASE       :      Tuple							=    FocalNetBackbone(config=UpperCAmelCase_      )
       model.to(UpperCAmelCase_      )
       model.eval()
       SCREAMING_SNAKE_CASE       :      Tuple							=    model(UpperCAmelCase_      )

       # verify feature maps
       self.parent.assertEqual(len(result.feature_maps      )					, len(config.out_features      )      )
       self.parent.assertListEqual(list(result.feature_maps[0].shape      )					, [self.batch_size, self.image_size, 8, 8]      )

       # verify channels
       self.parent.assertEqual(len(model.channels      )					, len(config.out_features      )      )
       self.parent.assertListEqual(model.channels					, config.hidden_sizes[:-1]      )

       # verify backbone works with out_features=None
       SCREAMING_SNAKE_CASE       :      Any							=    None
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    FocalNetBackbone(config=UpperCAmelCase_      )
       model.to(UpperCAmelCase_      )
       model.eval()
       SCREAMING_SNAKE_CASE       :      Any							=    model(UpperCAmelCase_      )

       # verify feature maps
       self.parent.assertEqual(len(result.feature_maps      )					, 1      )
       self.parent.assertListEqual(list(result.feature_maps[0].shape      )					, [self.batch_size, self.image_size * 2, 4, 4]      )

       # verify channels
       self.parent.assertEqual(len(model.channels      )					, 1      )
       self.parent.assertListEqual(model.channels					, [config.hidden_sizes[-1]]      )


     def 				_A       (				self       :	Dict					, UpperCAmelCase_       :	Dict					, UpperCAmelCase_       :	Dict					, UpperCAmelCase_       :	int      ):
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    FocalNetForMaskedImageModeling(config=UpperCAmelCase_      )
       model.to(UpperCAmelCase_      )
       model.eval()
       SCREAMING_SNAKE_CASE       :      List[str]							=    model(UpperCAmelCase_      )
       self.parent.assertEqual(
           result.reconstruction.shape					, (self.batch_size, self.num_channels, self.image_size, self.image_size)      )

       # test greyscale images
       SCREAMING_SNAKE_CASE       :      Dict							=    1
       SCREAMING_SNAKE_CASE       :      List[str]							=    FocalNetForMaskedImageModeling(UpperCAmelCase_      )
       model.to(UpperCAmelCase_      )
       model.eval()

       SCREAMING_SNAKE_CASE       :      int							=    floats_tensor([self.batch_size, 1, self.image_size, self.image_size]      )
       SCREAMING_SNAKE_CASE       :      Any							=    model(UpperCAmelCase_      )
       self.parent.assertEqual(result.reconstruction.shape					, (self.batch_size, 1, self.image_size, self.image_size)      )


     def 				_A       (				self       :	List[str]					, UpperCAmelCase_       :	str					, UpperCAmelCase_       :	Tuple					, UpperCAmelCase_       :	Optional[Any]      ):
       SCREAMING_SNAKE_CASE       :      List[str]							=    self.type_sequence_label_size
       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    FocalNetForImageClassification(UpperCAmelCase_      )
       model.to(UpperCAmelCase_      )
       model.eval()
       SCREAMING_SNAKE_CASE       :      Optional[int]							=    model(UpperCAmelCase_					, labels=UpperCAmelCase_      )
       self.parent.assertEqual(result.logits.shape					, (self.batch_size, self.type_sequence_label_size)      )

       # test greyscale images
       SCREAMING_SNAKE_CASE       :      int							=    1
       SCREAMING_SNAKE_CASE       :      List[str]							=    FocalNetForImageClassification(UpperCAmelCase_      )
       model.to(UpperCAmelCase_      )
       model.eval()

       SCREAMING_SNAKE_CASE       :      Dict							=    floats_tensor([self.batch_size, 1, self.image_size, self.image_size]      )
       SCREAMING_SNAKE_CASE       :      int							=    model(UpperCAmelCase_      )
       self.parent.assertEqual(result.logits.shape					, (self.batch_size, self.type_sequence_label_size)      )






     def 				_A       (				self       :	Dict      ):
       SCREAMING_SNAKE_CASE       :      List[Any]							=    self.prepare_config_and_inputs()

       SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE       :      List[str]							=    config_and_inputs
       SCREAMING_SNAKE_CASE       :      List[str]							=    {"pixel_values": pixel_values}
       return config, inputs_dict





@require_torch
class  SCREAMING_SNAKE_CASE			(			lowerCAmelCase      ,		lowerCAmelCase      ,		unittest.TestCase					):
     '''simple docstring'''


     UpperCamelCase_							:		int			=	(
         (
             FocalNetModel,
             FocalNetForImageClassification,
             FocalNetForMaskedImageModeling,
             FocalNetBackbone,
         )
         if is_torch_available()
         else ()
     )
     UpperCamelCase_							:		Optional[int]			=	(
         {'''feature-extraction''': FocalNetModel, '''image-classification''': FocalNetForImageClassification}
         if is_torch_available()
         else {}
     )
     UpperCamelCase_							:		Tuple			=	False

     UpperCamelCase_							:		Optional[Any]			=	False
     UpperCamelCase_							:		Optional[Any]			=	False
     UpperCamelCase_							:		Optional[int]			=	False
     UpperCamelCase_							:		Union[str, Any]			=	False


     def 				_A       (				self       :	List[str]      ):
       SCREAMING_SNAKE_CASE       :      int							=    FocalNetModelTester(self      )
       SCREAMING_SNAKE_CASE       :      List[str]							=    ConfigTester(self					, config_class=UpperCAmelCase_					, embed_dim=37					, has_text_modality=UpperCAmelCase_      )


     def 				_A       (				self       :	List[str]      ):
       self.create_and_test_config_common_properties()
       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       :	List[str]      ):
       return


     def 				_A       (				self       :	Dict      ):
       SCREAMING_SNAKE_CASE       :      int							=    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*UpperCAmelCase_      )


     def 				_A       (				self       :	Any      ):
       SCREAMING_SNAKE_CASE       :      List[Any]							=    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_backbone(*UpperCAmelCase_      )


     def 				_A       (				self       :	Dict      ):
       SCREAMING_SNAKE_CASE       :      Dict							=    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_image_modeling(*UpperCAmelCase_      )


     def 				_A       (				self       :	List[str]      ):
       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*UpperCAmelCase_      )


     @unittest.skip(reason="FocalNet does not use inputs_embeds"      )
     def 				_A       (				self       :	Union[str, Any]      ):
       pass


     @unittest.skip(reason="FocalNet does not use feedforward chunking"      )
     def 				_A       (				self       :	Any      ):
       pass


     def 				_A       (				self       :	Any      ):
       SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE       :      int							=    self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes[:-1]:
         SCREAMING_SNAKE_CASE       :      List[str]							=    model_class(UpperCAmelCase_      )
         self.assertIsInstance(model.get_input_embeddings()					, (nn.Module)      )
         SCREAMING_SNAKE_CASE       :      List[str]							=    model.get_output_embeddings()
         self.assertTrue(x is None or isinstance(UpperCAmelCase_					, nn.Linear      )      )


     def 				_A       (				self       :	Any      ):
       SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE       :      Dict							=    self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes[:-1]:
         SCREAMING_SNAKE_CASE       :      Tuple							=    model_class(UpperCAmelCase_      )
         SCREAMING_SNAKE_CASE       :      List[Any]							=    inspect.signature(model.forward      )
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         SCREAMING_SNAKE_CASE       :      List[Any]							=    [*signature.parameters.keys()]

         SCREAMING_SNAKE_CASE       :      List[str]							=    ["pixel_values"]
         self.assertListEqual(arg_names[:1]					, UpperCAmelCase_      )


     def 				_A       (				self       :	Union[str, Any]					, UpperCAmelCase_       :	Optional[Any]					, UpperCAmelCase_       :	Optional[Any]					, UpperCAmelCase_       :	Optional[Any]					, UpperCAmelCase_       :	str      ):
       SCREAMING_SNAKE_CASE       :      List[Any]							=    model_class(UpperCAmelCase_      )
       model.to(UpperCAmelCase_      )
       model.eval()

       with torch.no_grad():
         SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    model(**self._prepare_for_class(UpperCAmelCase_					, UpperCAmelCase_      )      )

       SCREAMING_SNAKE_CASE       :      Optional[Any]							=    outputs.hidden_states

       SCREAMING_SNAKE_CASE       :      Dict							=    getattr(
           self.model_tester					, "expected_num_hidden_layers"					, len(self.model_tester.depths      ) + 1      )
       self.assertEqual(len(UpperCAmelCase_      )					, UpperCAmelCase_      )

       # FocalNet has a different seq_length
       SCREAMING_SNAKE_CASE       :      Tuple							=    (
           config.patch_size
           if isinstance(config.patch_size					, collections.abc.Iterable      )
           else (config.patch_size, config.patch_size)
       )

       SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

       self.assertListEqual(
           list(hidden_states[0].shape[-2:]      )					, [num_patches, self.model_tester.embed_dim]					, )

       SCREAMING_SNAKE_CASE       :      Any							=    outputs.reshaped_hidden_states
       self.assertEqual(len(UpperCAmelCase_      )					, UpperCAmelCase_      )

       SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE       :      Optional[int]							=    reshaped_hidden_states[0].shape
       SCREAMING_SNAKE_CASE       :      Tuple							=    (
           reshaped_hidden_states[0].view(UpperCAmelCase_					, UpperCAmelCase_					, height * width      ).permute(0					, 2					, 1      )
       )
       self.assertListEqual(
           list(reshaped_hidden_states.shape[-2:]      )					, [num_patches, self.model_tester.embed_dim]					, )


     def 				_A       (				self       :	Any      ):
       SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE       :      Any							=    self.model_tester.prepare_config_and_inputs_for_common()

       SCREAMING_SNAKE_CASE       :      Any							=    (
           self.model_tester.image_size
           if isinstance(self.model_tester.image_size					, collections.abc.Iterable      )
           else (self.model_tester.image_size, self.model_tester.image_size)
       )

       for model_class in self.all_model_classes[:-1]:
         SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    True
         self.check_hidden_states_output(UpperCAmelCase_					, UpperCAmelCase_					, UpperCAmelCase_					, UpperCAmelCase_      )

         # check that output_hidden_states also work using config
         del inputs_dict["output_hidden_states"]
         SCREAMING_SNAKE_CASE       :      Any							=    True

         self.check_hidden_states_output(UpperCAmelCase_					, UpperCAmelCase_					, UpperCAmelCase_					, UpperCAmelCase_      )


     def 				_A       (				self       :	Any      ):
       SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE       :      Optional[Any]							=    self.model_tester.prepare_config_and_inputs_for_common()
       SCREAMING_SNAKE_CASE       :      Tuple							=    3

       SCREAMING_SNAKE_CASE       :      str							=    (
           self.model_tester.image_size
           if isinstance(self.model_tester.image_size					, collections.abc.Iterable      )
           else (self.model_tester.image_size, self.model_tester.image_size)
       )
       SCREAMING_SNAKE_CASE       :      Dict							=    (
           config.patch_size
           if isinstance(config.patch_size					, collections.abc.Iterable      )
           else (config.patch_size, config.patch_size)
       )

       SCREAMING_SNAKE_CASE       :      str							=    image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
       SCREAMING_SNAKE_CASE       :      List[Any]							=    image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

       for model_class in self.all_model_classes[:-1]:
         SCREAMING_SNAKE_CASE       :      Optional[Any]							=    True
         self.check_hidden_states_output(UpperCAmelCase_					, UpperCAmelCase_					, UpperCAmelCase_					, (padded_height, padded_width)      )

         # check that output_hidden_states also work using config
         del inputs_dict["output_hidden_states"]
         SCREAMING_SNAKE_CASE       :      Union[str, Any]							=    True
         self.check_hidden_states_output(UpperCAmelCase_					, UpperCAmelCase_					, UpperCAmelCase_					, (padded_height, padded_width)      )


     @slow
     def 				_A       (				self       :	int      ):
       for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         SCREAMING_SNAKE_CASE       :      str							=    FocalNetModel.from_pretrained(UpperCAmelCase_      )
         self.assertIsNotNone(UpperCAmelCase_      )






     def 				_A       (				self       :	str      ):
       SCREAMING_SNAKE_CASE						,  SCREAMING_SNAKE_CASE       :      Dict							=    self.model_tester.prepare_config_and_inputs_for_common()

       SCREAMING_SNAKE_CASE       :      Any							=    _config_zero_init(UpperCAmelCase_      )
       for model_class in self.all_model_classes:
         SCREAMING_SNAKE_CASE       :      Optional[int]							=    model_class(config=UpperCAmelCase_      )
         for name, param in model.named_parameters():
           if "embeddings" not in name and param.requires_grad:
             self.assertIn(
                 ((param.data.mean() * 1E9).round() / 1E9).item()					, [0.0, 1.0]					, msg=f'''Parameter {name} of model {model_class} seems not properly initialized'''					, )





@require_vision
@require_torch
class  SCREAMING_SNAKE_CASE			(			unittest.TestCase					):
     '''simple docstring'''


     @cached_property
     def 				_A       (				self       :	Optional[Any]      ):
       # TODO update organization
       return AutoImageProcessor.from_pretrained("microsoft/focalnet-tiny"      ) if is_vision_available() else None






     @slow
     def 				_A       (				self       :	Tuple      ):
       SCREAMING_SNAKE_CASE       :      Dict							=    FocalNetForImageClassification.from_pretrained("microsoft/focalnet-tiny"      ).to(UpperCAmelCase_      )
       SCREAMING_SNAKE_CASE       :      Any							=    self.default_image_processor

       SCREAMING_SNAKE_CASE       :      str							=    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"      )
       SCREAMING_SNAKE_CASE       :      str							=    image_processor(images=UpperCAmelCase_					, return_tensors="pt"      ).to(UpperCAmelCase_      )

       # forward pass
       with torch.no_grad():
         SCREAMING_SNAKE_CASE       :      Optional[Any]							=    model(**UpperCAmelCase_      )

       # verify the logits
       SCREAMING_SNAKE_CASE       :      Dict							=    torch.Size((1, 1000)      )
       self.assertEqual(outputs.logits.shape					, UpperCAmelCase_      )
       SCREAMING_SNAKE_CASE       :      Any							=    torch.tensor([0.2_166, -0.4_368, 0.2_191]      ).to(UpperCAmelCase_      )
       self.assertTrue(torch.allclose(outputs.logits[0, :3]					, UpperCAmelCase_					, atol=1E-4      )      )
       self.assertTrue(outputs.logits.argmax(dim=-1      ).item()					, 281      )





@require_torch
class  SCREAMING_SNAKE_CASE			(			lowerCAmelCase      ,		unittest.TestCase					):
     '''simple docstring'''


     UpperCamelCase_							:		Any			=	(FocalNetBackbone,) if is_torch_available() else ()
     UpperCamelCase_							:		int			=	FocalNetConfig

     UpperCamelCase_							:		Tuple			=	False


     def 				_A       (				self       :	Dict      ):
       SCREAMING_SNAKE_CASE       :      List[str]							=    FocalNetModelTester(self      )














from typing import TYPE_CHECKING

from ....utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


snake_case    				=		{
    """configuration_trajectory_transformer""": [
        """TRAJECTORY_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """TrajectoryTransformerConfig""",
    ],
}

try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   snake_case    				=		[
       """TRAJECTORY_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST""",
       """TrajectoryTransformerModel""",
       """TrajectoryTransformerPreTrainedModel""",
       """load_tf_weights_in_trajectory_transformer""",
   ]


if TYPE_CHECKING:
   from .configuration_trajectory_transformer import (
       TRAJECTORY_TRANSFORMER_PRETRAINED_CONFIG_ARCHIVE_MAP,
       TrajectoryTransformerConfig,
   )

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_trajectory_transformer import (
          TRAJECTORY_TRANSFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
          TrajectoryTransformerModel,
          TrajectoryTransformerPreTrainedModel,
          load_tf_weights_in_trajectory_transformer,
      )


else:
   import sys

   snake_case    				=		_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)






