





'''simple docstring'''






import inspect
import unittest

import numpy as np

from tests.test_modeling_common import floats_tensor
from transformers import DetrConfig, MaskFormerConfig, SwinConfig, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import MaskFormerForInstanceSegmentation, MaskFormerModel

	if is_vision_available():
		from transformers import MaskFormerImageProcessor

if is_vision_available():
	from PIL import Image




class  _A :

		def __init__(   self					:   Any  ,      __magic_name__					:   Dict  ,      __magic_name__					:   Optional[Any]=2  ,      __magic_name__					:   List[Any]=True  ,      __magic_name__					:   Optional[Any]=False  ,      __magic_name__					:   Optional[int]=10  ,      __magic_name__					:   Optional[int]=3  ,      __magic_name__					:   Optional[int]=32 * 4  ,      __magic_name__					:   int=32 * 6  ,      __magic_name__					:   List[Any]=4  ,      __magic_name__					:   List[Any]=32  ,      )					->    Dict:


					"""simple docstring"""

					__snake_case					:      str							      =     parent
					__snake_case					:      int							      =     batch_size
					__snake_case					:      int							      =     is_training
					__snake_case					:      Tuple							      =     use_auxiliary_loss
					__snake_case					:      List[str]							      =     num_queries
					__snake_case					:      str							      =     num_channels
					__snake_case					:      Dict							      =     min_size
					__snake_case					:      int							      =     max_size
					__snake_case					:      List[Any]							      =     num_labels
					__snake_case					:      Union[str, Any]							      =     mask_feature_size

		def 	lowercase__     (   self					:   str			)					->    Dict:


					"""simple docstring"""

					__snake_case					:      str							      =     floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]			).to(
					    __magic_name__			)

					__snake_case					:      Dict							      =     torch.ones([self.batch_size, self.min_size, self.max_size]  ,      device=__magic_name__			)

					__snake_case					:      Optional[Any]							      =     (
					    torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size]  ,      device=__magic_name__			) > 0.5
					).float()
					__snake_case					:      Union[str, Any]							      =     (torch.rand((self.batch_size, self.num_labels)  ,      device=__magic_name__			) > 0.5).long()

					__snake_case					:      Tuple							      =     self.get_config()
					return config, pixel_values, pixel_mask, mask_labels, class_labels

		def 	lowercase__     (   self					:   Optional[Any]			)					->    Any:


					"""simple docstring"""

					return MaskFormerConfig.from_backbone_and_decoder_configs(
					    backbone_config=SwinConfig(
					        depths=[1, 1, 1, 1]  ,      )  ,      decoder_config=DetrConfig(
					        decoder_ffn_dim=1_28  ,      num_queries=self.num_queries  ,      decoder_attention_heads=2  ,      d_model=self.mask_feature_size  ,      )  ,      mask_feature_size=self.mask_feature_size  ,      fpn_feature_size=self.mask_feature_size  ,      num_channels=self.num_channels  ,      num_labels=self.num_labels  ,      )

		def 	lowercase__     (   self					:   Optional[Any]			)					->    Union[str, Any]:


					"""simple docstring"""

					__snake_case      ,     __snake_case      ,     __snake_case      ,     __snake_case      ,     __snake_case					:      Any							      =     self.prepare_config_and_inputs()
					__snake_case					:      str							      =     {"""pixel_values""": pixel_values, """pixel_mask""": pixel_mask}
					return config, inputs_dict

		def 	lowercase__     (   self					:   str  ,      __magic_name__					:   int  ,      __magic_name__					:   int			)					->    Optional[Any]:


					"""simple docstring"""

					__snake_case					:      Any							      =     output.encoder_hidden_states
					__snake_case					:      List[str]							      =     output.pixel_decoder_hidden_states
					__snake_case					:      str							      =     output.transformer_decoder_hidden_states

					self.parent.assertTrue(len(__magic_name__			)  ,      len(config.backbone_config.depths			)			)
					self.parent.assertTrue(len(__magic_name__			)  ,      len(config.backbone_config.depths			)			)
					self.parent.assertTrue(len(__magic_name__			)  ,      config.decoder_config.decoder_layers			)

		def 	lowercase__     (   self					:   List[str]  ,      __magic_name__					:   Union[str, Any]  ,      __magic_name__					:   int  ,      __magic_name__					:   int  ,      __magic_name__					:   Tuple=False			)					->    int:


					"""simple docstring"""

					with torch.no_grad():
								__snake_case					:      str							      =     MaskFormerModel(config=__magic_name__			)
								model.to(__magic_name__			)
								model.eval()

								__snake_case					:      List[Any]							      =     model(pixel_values=__magic_name__  ,      pixel_mask=__magic_name__			)
								__snake_case					:      int							      =     model(__magic_name__  ,      output_hidden_states=__magic_name__			)
					# the correct shape of output.transformer_decoder_hidden_states ensure the correcteness of the
					# encoder and pixel decoder
					self.parent.assertEqual(
					    output.transformer_decoder_last_hidden_state.shape  ,      (self.batch_size, self.num_queries, self.mask_feature_size)  ,      )
					# let's ensure the other two hidden state exists
					self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None			)
					self.parent.assertTrue(output.encoder_last_hidden_state is not None			)

					if output_hidden_states:
								self.check_output_hidden_state(__magic_name__  ,      __magic_name__			)

		def 	lowercase__     (   self					:   Union[str, Any]  ,      __magic_name__					:   Dict  ,      __magic_name__					:   Optional[int]  ,      __magic_name__					:   List[Any]  ,      __magic_name__					:   Optional[int]  ,      __magic_name__					:   Union[str, Any]			)					->    Tuple:


					"""simple docstring"""

					__snake_case					:      Optional[Any]							      =     MaskFormerForInstanceSegmentation(config=__magic_name__			)
					model.to(__magic_name__			)
					model.eval()

					def comm_check_on_output(__magic_name__					:   Dict			):
								# let's still check that all the required stuff is there
								self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None			)
								self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None			)
								self.parent.assertTrue(result.encoder_last_hidden_state is not None			)
								# okay, now we need to check the logits shape
								# due to the encoder compression, masks have a //4 spatial size
								self.parent.assertEqual(
								    result.masks_queries_logits.shape  ,      (self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4)  ,      )
								# + 1 for null class
								self.parent.assertEqual(
								    result.class_queries_logits.shape  ,      (self.batch_size, self.num_queries, self.num_labels + 1)			)

					with torch.no_grad():
								__snake_case					:      Tuple							      =     model(pixel_values=__magic_name__  ,      pixel_mask=__magic_name__			)
								__snake_case					:      List[Any]							      =     model(__magic_name__			)

								comm_check_on_output(__magic_name__			)

								__snake_case					:      List[Any]							      =     model(
								    pixel_values=__magic_name__  ,      pixel_mask=__magic_name__  ,      mask_labels=__magic_name__  ,      class_labels=__magic_name__			)

					comm_check_on_output(__magic_name__			)

					self.parent.assertTrue(result.loss is not None			)
					self.parent.assertEqual(result.loss.shape  ,      torch.Size([1]			)			)





@require_torch
class  _A (					__lowercase						,					__lowercase						,					unittest.TestCase		):
		lowercase__:   str				     =   (MaskFormerModel, MaskFormerForInstanceSegmentation) if is_torch_available() else ()
		lowercase__:   Tuple				     =   (
		    {'''feature-extraction''': MaskFormerModel, '''image-segmentation''': MaskFormerForInstanceSegmentation}
		    if is_torch_available()
		    else {}
		)

		lowercase__:   Optional[Any]				     =   False
		lowercase__:   Union[str, Any]				     =   False
		lowercase__:   Optional[int]				     =   False
		lowercase__:   Dict				     =   False

		def 	lowercase__     (   self					:   Optional[Any]			)					->    Tuple:


					"""simple docstring"""

					__snake_case					:      Tuple							      =     MaskFormerModelTester(self			)
					__snake_case					:      Optional[int]							      =     ConfigTester(self  ,      config_class=__magic_name__  ,      has_text_modality=__magic_name__			)

		def 	lowercase__     (   self					:   List[Any]			)					->    Dict:


					"""simple docstring"""

					self.config_tester.run_common_tests()

		def 	lowercase__     (   self					:   Tuple			)					->    Union[str, Any]:


					"""simple docstring"""

					__snake_case      ,     __snake_case					:      List[str]							      =     self.model_tester.prepare_config_and_inputs_for_common()
					self.model_tester.create_and_check_maskformer_model(__magic_name__  ,      **__magic_name__  ,      output_hidden_states=__magic_name__			)

		def 	lowercase__     (   self					:   Any			)					->    str:


					"""simple docstring"""

					__snake_case					:      int							      =     self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_maskformer_instance_segmentation_head_model(*__magic_name__			)

		@unittest.skip(reason="""MaskFormer does not use inputs_embeds"""			)
		def 	lowercase__     (   self					:   Optional[int]			)					->    int:


					"""simple docstring"""

					pass

		@unittest.skip(reason="""MaskFormer does not have a get_input_embeddings method"""			)
		def 	lowercase__     (   self					:   Any			)					->    Tuple:


					"""simple docstring"""

					pass

		@unittest.skip(reason="""MaskFormer is not a generative model"""			)
		def 	lowercase__     (   self					:   Optional[Any]			)					->    Optional[Any]:


					"""simple docstring"""

					pass

		@unittest.skip(reason="""MaskFormer does not use token embeddings"""			)
		def 	lowercase__     (   self					:   List[str]			)					->    List[str]:


					"""simple docstring"""

					pass

		@require_torch_multi_gpu
		@unittest.skip(
		    reason="""MaskFormer has some layers using `add_module` which doesn't work well with `nn.DataParallel`"""			)
		def 	lowercase__     (   self					:   Dict			)					->    Tuple:


					"""simple docstring"""

					pass

		@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""			)
		def 	lowercase__     (   self					:   Any			)					->    Optional[Any]:


					"""simple docstring"""

					pass

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


					"""simple docstring"""

					__snake_case      ,     __snake_case					:      str							      =     self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
								__snake_case					:      List[str]							      =     model_class(__magic_name__			)
								__snake_case					:      Dict							      =     inspect.signature(model.forward			)
								# signature.parameters is an OrderedDict => so arg_names order is deterministic
								__snake_case					:      Union[str, Any]							      =     [*signature.parameters.keys()]

								__snake_case					:      str							      =     ["""pixel_values"""]
								self.assertListEqual(arg_names[:1]  ,      __magic_name__			)

		@slow
		def 	lowercase__     (   self					:   List[Any]			)					->    Tuple:


					"""simple docstring"""

					for model_name in ["facebook/maskformer-swin-small-coco"]:
								__snake_case					:      str							      =     MaskFormerModel.from_pretrained(__magic_name__			)
								self.assertIsNotNone(__magic_name__			)

		def 	lowercase__     (   self					:   int			)					->    List[str]:


					"""simple docstring"""

					__snake_case					:      Any							      =     (self.model_tester.min_size,) * 2
					__snake_case					:      List[Any]							      =     {
					    """pixel_values""": torch.randn((2, 3, *size)  ,      device=__magic_name__			),
					    """mask_labels""": torch.randn((2, 10, *size)  ,      device=__magic_name__			),
					    """class_labels""": torch.zeros(2  ,      10  ,      device=__magic_name__			).long(),
					}

					__snake_case					:      str							      =     MaskFormerForInstanceSegmentation(MaskFormerConfig()			).to(__magic_name__			)
					__snake_case					:      Optional[Any]							      =     model(**__magic_name__			)
					self.assertTrue(outputs.loss is not None			)

		def 	lowercase__     (   self					:   List[str]			)					->    Dict:


					"""simple docstring"""

					__snake_case      ,     __snake_case					:      Any							      =     self.model_tester.prepare_config_and_inputs_for_common()
					self.model_tester.create_and_check_maskformer_model(__magic_name__  ,      **__magic_name__  ,      output_hidden_states=__magic_name__			)

		def 	lowercase__     (   self					:   Optional[int]			)					->    Dict:


					"""simple docstring"""

					__snake_case      ,     __snake_case					:      Tuple							      =     self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
								__snake_case					:      List[Any]							      =     model_class(__magic_name__			).to(__magic_name__			)
								__snake_case					:      Any							      =     model(**__magic_name__  ,      output_attentions=__magic_name__			)
								self.assertTrue(outputs.attentions is not None			)

		def 	lowercase__     (   self					:   List[Any]			)					->    List[str]:


					"""simple docstring"""

					if not self.model_tester.is_training:
								return
					# only MaskFormerForInstanceSegmentation has the loss
					__snake_case					:      Dict							      =     self.all_model_classes[1]
					__snake_case      ,     __snake_case      ,     __snake_case      ,     __snake_case      ,     __snake_case					:      Any							      =     self.model_tester.prepare_config_and_inputs()

					__snake_case					:      Union[str, Any]							      =     model_class(__magic_name__			)
					model.to(__magic_name__			)
					model.train()

					__snake_case					:      Dict							      =     model(__magic_name__  ,      mask_labels=__magic_name__  ,      class_labels=__magic_name__			).loss
					loss.backward()

		def 	lowercase__     (   self					:   Tuple			)					->    str:


					"""simple docstring"""

					__snake_case					:      Tuple							      =     self.all_model_classes[1]
					__snake_case      ,     __snake_case      ,     __snake_case      ,     __snake_case      ,     __snake_case					:      List[str]							      =     self.model_tester.prepare_config_and_inputs()
					__snake_case					:      Any							      =     True
					__snake_case					:      str							      =     True

					__snake_case					:      List[Any]							      =     model_class(__magic_name__			)
					model.to(__magic_name__			)
					model.train()

					__snake_case					:      str							      =     model(__magic_name__  ,      mask_labels=__magic_name__  ,      class_labels=__magic_name__			)

					__snake_case					:      Dict							      =     outputs.encoder_hidden_states[0]
					encoder_hidden_states.retain_grad()

					__snake_case					:      Union[str, Any]							      =     outputs.pixel_decoder_hidden_states[0]
					pixel_decoder_hidden_states.retain_grad()
					# we requires_grad=True in inputs_embeds (line 2152), the original implementation don't
					__snake_case					:      Dict							      =     outputs.transformer_decoder_hidden_states[0]
					transformer_decoder_hidden_states.retain_grad()

					__snake_case					:      Optional[Any]							      =     outputs.attentions[0]
					attentions.retain_grad()

					outputs.loss.backward(retain_graph=__magic_name__			)

					self.assertIsNotNone(encoder_hidden_states.grad			)
					self.assertIsNotNone(pixel_decoder_hidden_states.grad			)
					self.assertIsNotNone(transformer_decoder_hidden_states.grad			)
					self.assertIsNotNone(attentions.grad			)





__UpperCamelCase					    =	1E-4







def 					_a						(       ) ->				Optional[Any]:



			"""simple docstring"""


			__snake_case					:      List[Any]							      =     Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" )
			return image




@require_vision
@slow
class  _A (					unittest.TestCase		):

		@cached_property
		def 	lowercase__     (   self					:   int			)					->    List[Any]:


					"""simple docstring"""

					return (
					    MaskFormerImageProcessor.from_pretrained("""facebook/maskformer-swin-small-coco"""			)
					    if is_vision_available()
					    else None
					)

		def 	lowercase__     (   self					:   Tuple			)					->    Optional[int]:


					"""simple docstring"""

					__snake_case					:      List[str]							      =     MaskFormerModel.from_pretrained("""facebook/maskformer-swin-small-coco"""			).to(__magic_name__			)
					__snake_case					:      List[str]							      =     self.default_image_processor
					__snake_case					:      Optional[int]							      =     prepare_img()
					__snake_case					:      Optional[int]							      =     image_processor(__magic_name__  ,      return_tensors="""pt"""			).to(__magic_name__			)
					__snake_case					:      str							      =     inputs["""pixel_values"""].shape
					# check size is divisible by 32
					self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0			)
					# check size
					self.assertEqual(__magic_name__  ,      (1, 3, 8_00, 10_88)			)

					with torch.no_grad():
								__snake_case					:      Dict							      =     model(**__magic_name__			)

					__snake_case					:      Tuple							      =     torch.tensor(
					    [[-0.0482, 0.9228, 0.4951], [-0.2547, 0.8017, 0.8527], [-0.0069, 0.3385, -0.0089]]			).to(__magic_name__			)
					self.assertTrue(
					    torch.allclose(
					        outputs.encoder_last_hidden_state[0, 0, :3, :3]  ,      __magic_name__  ,      atol=__magic_name__			)			)

					__snake_case					:      Optional[Any]							      =     torch.tensor(
					    [[-0.8422, -0.8434, -0.9718], [-1.0144, -0.5565, -0.4195], [-1.0038, -0.4484, -0.1961]]			).to(__magic_name__			)
					self.assertTrue(
					    torch.allclose(
					        outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3]  ,      __magic_name__  ,      atol=__magic_name__			)			)

					__snake_case					:      Dict							      =     torch.tensor(
					    [[0.2852, -0.0159, 0.9735], [0.6254, 0.1858, 0.8529], [-0.0680, -0.4116, 1.8413]]			).to(__magic_name__			)
					self.assertTrue(
					    torch.allclose(
					        outputs.transformer_decoder_last_hidden_state[0, :3, :3]  ,      __magic_name__  ,      atol=__magic_name__			)			)

		def 	lowercase__     (   self					:   List[Any]			)					->    Optional[int]:


					"""simple docstring"""

					__snake_case					:      Optional[Any]							      =     (
					    MaskFormerForInstanceSegmentation.from_pretrained("""facebook/maskformer-swin-small-coco"""			)
					    .to(__magic_name__			)
					    .eval()
					)
					__snake_case					:      List[Any]							      =     self.default_image_processor
					__snake_case					:      List[str]							      =     prepare_img()
					__snake_case					:      Tuple							      =     image_processor(__magic_name__  ,      return_tensors="""pt"""			).to(__magic_name__			)
					__snake_case					:      Optional[int]							      =     inputs["""pixel_values"""].shape
					# check size is divisible by 32
					self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0			)
					# check size
					self.assertEqual(__magic_name__  ,      (1, 3, 8_00, 10_88)			)

					with torch.no_grad():
								__snake_case					:      int							      =     model(**__magic_name__			)
					# masks_queries_logits
					__snake_case					:      str							      =     outputs.masks_queries_logits
					self.assertEqual(
					    masks_queries_logits.shape  ,      (1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)  ,      )
					__snake_case					:      Optional[int]							      =     [
					    [-1.3737124, -1.7724937, -1.9364233],
					    [-1.5977281, -1.9867939, -2.1523695],
					    [-1.5795398, -1.9269832, -2.093942],
					]
					__snake_case					:      Optional[Any]							      =     torch.tensor(__magic_name__			).to(__magic_name__			)
					self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]  ,      __magic_name__  ,      atol=__magic_name__			)			)
					# class_queries_logits
					__snake_case					:      Optional[Any]							      =     outputs.class_queries_logits
					self.assertEqual(
					    class_queries_logits.shape  ,      (1, model.config.decoder_config.num_queries, model.config.num_labels + 1)			)
					__snake_case					:      Optional[int]							      =     torch.tensor(
					    [
					        [1.6_512E00, -5.2_572E00, -3.3_519E00],
					        [3.6_169E-02, -5.9_025E00, -2.9_313E00],
					        [1.0_766E-04, -7.7_630E00, -5.1_263E00],
					    ]			).to(__magic_name__			)
					self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]  ,      __magic_name__  ,      atol=__magic_name__			)			)

		def 	lowercase__     (   self					:   Any			)					->    Any:


					"""simple docstring"""

					__snake_case					:      List[Any]							      =     (
					    MaskFormerForInstanceSegmentation.from_pretrained("""facebook/maskformer-resnet101-coco-stuff"""			)
					    .to(__magic_name__			)
					    .eval()
					)
					__snake_case					:      str							      =     self.default_image_processor
					__snake_case					:      Union[str, Any]							      =     prepare_img()
					__snake_case					:      List[str]							      =     image_processor(__magic_name__  ,      return_tensors="""pt"""			).to(__magic_name__			)
					__snake_case					:      Dict							      =     inputs["""pixel_values"""].shape
					# check size is divisible by 32
					self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0			)
					# check size
					self.assertEqual(__magic_name__  ,      (1, 3, 8_00, 10_88)			)

					with torch.no_grad():
								__snake_case					:      str							      =     model(**__magic_name__			)
					# masks_queries_logits
					__snake_case					:      List[Any]							      =     outputs.masks_queries_logits
					self.assertEqual(
					    masks_queries_logits.shape  ,      (1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)  ,      )
					__snake_case					:      List[Any]							      =     [[-0.9046, -2.6366, -4.6062], [-3.4179, -5.7890, -8.8057], [-4.9179, -7.6560, -10.7711]]
					__snake_case					:      Union[str, Any]							      =     torch.tensor(__magic_name__			).to(__magic_name__			)
					self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]  ,      __magic_name__  ,      atol=__magic_name__			)			)
					# class_queries_logits
					__snake_case					:      Union[str, Any]							      =     outputs.class_queries_logits
					self.assertEqual(
					    class_queries_logits.shape  ,      (1, model.config.decoder_config.num_queries, model.config.num_labels + 1)			)
					__snake_case					:      Dict							      =     torch.tensor(
					    [[4.7188, -3.2585, -2.8857], [6.6871, -2.9181, -1.2487], [7.2449, -2.2764, -2.1874]]			).to(__magic_name__			)
					self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]  ,      __magic_name__  ,      atol=__magic_name__			)			)

		def 	lowercase__     (   self					:   Optional[Any]			)					->    List[Any]:


					"""simple docstring"""

					__snake_case					:      List[str]							      =     (
					    MaskFormerForInstanceSegmentation.from_pretrained("""facebook/maskformer-swin-small-coco"""			)
					    .to(__magic_name__			)
					    .eval()
					)
					__snake_case					:      List[str]							      =     self.default_image_processor

					__snake_case					:      str							      =     image_processor(
					    [np.zeros((3, 8_00, 13_33)			), np.zeros((3, 8_00, 13_33)			)]  ,      segmentation_maps=[np.zeros((3_84, 3_84)			).astype(np.floataa			), np.zeros((3_84, 3_84)			).astype(np.floataa			)]  ,      return_tensors="""pt"""  ,      )

					__snake_case					:      List[str]							      =     inputs["""pixel_values"""].to(__magic_name__			)
					__snake_case					:      Optional[Any]							      =     [el.to(__magic_name__			) for el in inputs["""mask_labels"""]]
					__snake_case					:      Dict							      =     [el.to(__magic_name__			) for el in inputs["""class_labels"""]]

					with torch.no_grad():
								__snake_case					:      Any							      =     model(**__magic_name__			)

					self.assertTrue(outputs.loss is not None			)







'''simple docstring'''





from typing import TYPE_CHECKING

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


__a  			=						{
    "configuration_gpt_bigcode": ["GPT_BIGCODE_PRETRAINED_CONFIG_ARCHIVE_MAP", "GPTBigCodeConfig"],
}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __a  			=						[
           "GPT_BIGCODE_PRETRAINED_MODEL_ARCHIVE_LIST",
           "GPTBigCodeForSequenceClassification",
           "GPTBigCodeForTokenClassification",
           "GPTBigCodeForCausalLM",
           "GPTBigCodeModel",
           "GPTBigCodePreTrainedModel",
       ]

if TYPE_CHECKING:
       from .configuration_gpt_bigcode import GPT_BIGCODE_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTBigCodeConfig

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_gpt_bigcode import (
                  GPT_BIGCODE_PRETRAINED_MODEL_ARCHIVE_LIST,
                  GPTBigCodeForCausalLM,
                  GPTBigCodeForSequenceClassification,
                  GPTBigCodeForTokenClassification,
                  GPTBigCodeModel,
                  GPTBigCodePreTrainedModel,
              )


else:
       import sys

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