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   lowerCamelCase					:
  """simple docstring"""







  def __init__(							self :       Optional[int]  ,     __magic_name__ :       Dict  ,     __magic_name__ :       Union[str, Any]=2  ,     __magic_name__ :       List[str]=True  ,     __magic_name__ :       List[Any]=False  ,     __magic_name__ :       int=10  ,     __magic_name__ :       List[str]=3  ,     __magic_name__ :       Union[str, Any]=32 * 4  ,     __magic_name__ :       List[Any]=32 * 6  ,     __magic_name__ :       Dict=4  ,     __magic_name__ :       int=32  ,     )  ->	List[Any]:
        SCREAMING_SNAKE_CASE_          =  parent
        SCREAMING_SNAKE_CASE_          =  batch_size
        SCREAMING_SNAKE_CASE_          =  is_training
        SCREAMING_SNAKE_CASE_          =  use_auxiliary_loss
        SCREAMING_SNAKE_CASE_          =  num_queries
        SCREAMING_SNAKE_CASE_          =  num_channels
        SCREAMING_SNAKE_CASE_          =  min_size
        SCREAMING_SNAKE_CASE_          =  max_size
        SCREAMING_SNAKE_CASE_          =  num_labels
        SCREAMING_SNAKE_CASE_          =  mask_feature_size







  def    __A     (							self :       Optional[int]   )  ->	Optional[int]:
        SCREAMING_SNAKE_CASE_          =  floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]   ).to(
            __magic_name__   )

        SCREAMING_SNAKE_CASE_          =  torch.ones([self.batch_size, self.min_size, self.max_size]  ,     device=__magic_name__   )

        SCREAMING_SNAKE_CASE_          =  (
            torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size]  ,     device=__magic_name__   ) > 0.5
        ).float()
        SCREAMING_SNAKE_CASE_          =  (torch.rand((self.batch_size, self.num_labels)  ,     device=__magic_name__   ) > 0.5).long()

        SCREAMING_SNAKE_CASE_          =  self.get_config()
        return config, pixel_values, pixel_mask, mask_labels, class_labels







  def    __A     (							self :       List[str]   )  ->	Dict:
        return MaskFormerConfig.from_backbone_and_decoder_configs(
            backbone_config=SwinConfig(
                depths=[1, 1, 1, 1]  ,     )  ,     decoder_config=DetrConfig(
                decoder_ffn_dim=128  ,     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    __A     (							self :       Tuple   )  ->	List[str]:
        SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_          =  self.prepare_config_and_inputs()
        SCREAMING_SNAKE_CASE_          =  {"pixel_values": pixel_values, "pixel_mask": pixel_mask}
        return config, inputs_dict







  def    __A     (							self :       Union[str, Any]  ,     __magic_name__ :       str  ,     __magic_name__ :       Dict   )  ->	Tuple:
        SCREAMING_SNAKE_CASE_          =  output.encoder_hidden_states
        SCREAMING_SNAKE_CASE_          =  output.pixel_decoder_hidden_states
        SCREAMING_SNAKE_CASE_          =  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    __A     (							self :       Union[str, Any]  ,     __magic_name__ :       Union[str, Any]  ,     __magic_name__ :       Optional[int]  ,     __magic_name__ :       int  ,     __magic_name__ :       Optional[int]=False   )  ->	Optional[Any]:
        with torch.no_grad():
              SCREAMING_SNAKE_CASE_          =  MaskFormerModel(config=__magic_name__   )
              model.to(__magic_name__   )
              model.eval()

              SCREAMING_SNAKE_CASE_          =  model(pixel_values=__magic_name__  ,     pixel_mask=__magic_name__   )
              SCREAMING_SNAKE_CASE_          =  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    __A     (							self :       List[Any]  ,     __magic_name__ :       Optional[int]  ,     __magic_name__ :       Tuple  ,     __magic_name__ :       List[Any]  ,     __magic_name__ :       int  ,     __magic_name__ :       List[str]   )  ->	Any:
        SCREAMING_SNAKE_CASE_          =  MaskFormerForInstanceSegmentation(config=__magic_name__   )
        model.to(__magic_name__   )
        model.eval()

        def comm_check_on_output(__magic_name__ :       List[Any]   ):
              # 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():
              SCREAMING_SNAKE_CASE_          =  model(pixel_values=__magic_name__  ,     pixel_mask=__magic_name__   )
              SCREAMING_SNAKE_CASE_          =  model(__magic_name__   )

              comm_check_on_output(__magic_name__   )

              SCREAMING_SNAKE_CASE_          =  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   lowerCamelCase					(SCREAMING_SNAKE_CASE__  ,      SCREAMING_SNAKE_CASE__  ,      unittest.TestCase					):
  """simple docstring"""







  lowerCamelCase__     =						(MaskFormerModel, MaskFormerForInstanceSegmentation) if is_torch_available() else ()
  lowerCamelCase__     =						(
      {'''feature-extraction''': MaskFormerModel, '''image-segmentation''': MaskFormerForInstanceSegmentation}
      if is_torch_available()
      else {}
  )

  lowerCamelCase__     =						False
  lowerCamelCase__     =						False
  lowerCamelCase__     =						False
  lowerCamelCase__     =						False







  def    __A     (							self :       Union[str, Any]   )  ->	List[str]:
        SCREAMING_SNAKE_CASE_          =  MaskFormerModelTester(self   )
        SCREAMING_SNAKE_CASE_          =  ConfigTester(self  ,     config_class=__magic_name__  ,     has_text_modality=__magic_name__   )







  def    __A     (							self :       Union[str, Any]   )  ->	Any:
        self.config_tester.run_common_tests()







  def    __A     (							self :       List[str]   )  ->	Optional[int]:
        SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_          =  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    __A     (							self :       int   )  ->	Union[str, Any]:
        SCREAMING_SNAKE_CASE_          =  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    __A     (							self :       List[str]   )  ->	List[Any]:
        pass







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







  @unittest.skip(reason="MaskFormer is not a generative model"   )
  def    __A     (							self :       Union[str, Any]   )  ->	str:
        pass







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







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







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







  def    __A     (							self :       List[Any]   )  ->	Optional[int]:
        SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_          =  self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
              SCREAMING_SNAKE_CASE_          =  model_class(__magic_name__   )
              SCREAMING_SNAKE_CASE_          =  inspect.signature(model.forward   )
              # signature.parameters is an OrderedDict => so arg_names order is deterministic
              SCREAMING_SNAKE_CASE_          =  [*signature.parameters.keys()]

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







  @slow
  def    __A     (							self :       Optional[int]   )  ->	List[Any]:
        for model_name in ["facebook/maskformer-swin-small-coco"]:
              SCREAMING_SNAKE_CASE_          =  MaskFormerModel.from_pretrained(__magic_name__   )
              self.assertIsNotNone(__magic_name__   )







  def    __A     (							self :       Tuple   )  ->	Union[str, Any]:
        SCREAMING_SNAKE_CASE_          =  (self.model_tester.min_size,) * 2
        SCREAMING_SNAKE_CASE_          =  {
            "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(),
        }

        SCREAMING_SNAKE_CASE_          =  MaskFormerForInstanceSegmentation(MaskFormerConfig()   ).to(__magic_name__   )
        SCREAMING_SNAKE_CASE_          =  model(**__magic_name__   )
        self.assertTrue(outputs.loss is not None   )







  def    __A     (							self :       Union[str, Any]   )  ->	Dict:
        SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_          =  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    __A     (							self :       Optional[Any]   )  ->	List[str]:
        SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_          =  self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
              SCREAMING_SNAKE_CASE_          =  model_class(__magic_name__   ).to(__magic_name__   )
              SCREAMING_SNAKE_CASE_          =  model(**__magic_name__  ,     output_attentions=__magic_name__   )
              self.assertTrue(outputs.attentions is not None   )







  def    __A     (							self :       List[Any]   )  ->	Optional[int]:
        if not self.model_tester.is_training:
              return
        # only MaskFormerForInstanceSegmentation has the loss
        SCREAMING_SNAKE_CASE_          =  self.all_model_classes[1]
        SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_          =  self.model_tester.prepare_config_and_inputs()

        SCREAMING_SNAKE_CASE_          =  model_class(__magic_name__   )
        model.to(__magic_name__   )
        model.train()

        SCREAMING_SNAKE_CASE_          =  model(__magic_name__  ,     mask_labels=__magic_name__  ,     class_labels=__magic_name__   ).loss
        loss.backward()







  def    __A     (							self :       List[str]   )  ->	Optional[Any]:
        # only MaskFormerForInstanceSegmentation has the loss
        SCREAMING_SNAKE_CASE_          =  self.all_model_classes[1]
        SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_     , SCREAMING_SNAKE_CASE_          =  self.model_tester.prepare_config_and_inputs()
        SCREAMING_SNAKE_CASE_          =  True
        SCREAMING_SNAKE_CASE_          =  True

        SCREAMING_SNAKE_CASE_          =  model_class(__magic_name__   )
        model.to(__magic_name__   )
        model.train()

        SCREAMING_SNAKE_CASE_          =  model(__magic_name__  ,     mask_labels=__magic_name__  ,     class_labels=__magic_name__   )

        SCREAMING_SNAKE_CASE_          =  outputs.encoder_hidden_states[0]
        encoder_hidden_states.retain_grad()

        SCREAMING_SNAKE_CASE_          =  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
        SCREAMING_SNAKE_CASE_          =  outputs.transformer_decoder_hidden_states[0]
        transformer_decoder_hidden_states.retain_grad()

        SCREAMING_SNAKE_CASE_          =  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   )



A     :  Optional[Any]					     =       1E-4

def      a__ (		):
      SCREAMING_SNAKE_CASE_          =  Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"				)
      return image





@require_vision
@slow
class   lowerCamelCase					(unittest.TestCase					):
  """simple docstring"""







  @cached_property
  def    __A     (							self :       int   )  ->	int:
        return (
            MaskFormerImageProcessor.from_pretrained("facebook/maskformer-swin-small-coco"   )
            if is_vision_available()
            else None
        )







  def    __A     (							self :       Tuple   )  ->	List[str]:
        SCREAMING_SNAKE_CASE_          =  MaskFormerModel.from_pretrained("facebook/maskformer-swin-small-coco"   ).to(__magic_name__   )
        SCREAMING_SNAKE_CASE_          =  self.default_image_processor
        SCREAMING_SNAKE_CASE_          =  prepare_img()
        SCREAMING_SNAKE_CASE_          =  image_processor(__magic_name__  ,     return_tensors="pt"   ).to(__magic_name__   )
        SCREAMING_SNAKE_CASE_          =  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, 800, 1_088)   )

        with torch.no_grad():
              SCREAMING_SNAKE_CASE_          =  model(**__magic_name__   )

        SCREAMING_SNAKE_CASE_          =  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__   )   )

        SCREAMING_SNAKE_CASE_          =  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__   )   )

        SCREAMING_SNAKE_CASE_          =  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    __A     (							self :       Union[str, Any]   )  ->	Union[str, Any]:
        SCREAMING_SNAKE_CASE_          =  (
            MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco"   )
            .to(__magic_name__   )
            .eval()
        )
        SCREAMING_SNAKE_CASE_          =  self.default_image_processor
        SCREAMING_SNAKE_CASE_          =  prepare_img()
        SCREAMING_SNAKE_CASE_          =  image_processor(__magic_name__  ,     return_tensors="pt"   ).to(__magic_name__   )
        SCREAMING_SNAKE_CASE_          =  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, 800, 1_088)   )

        with torch.no_grad():
              SCREAMING_SNAKE_CASE_          =  model(**__magic_name__   )
        # masks_queries_logits
        SCREAMING_SNAKE_CASE_          =  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)  ,     )
        SCREAMING_SNAKE_CASE_          =  [
            [-1.373_7124, -1.772_4937, -1.936_4233],
            [-1.597_7281, -1.986_7939, -2.152_3695],
            [-1.579_5398, -1.926_9832, -2.09_3942],
        ]
        SCREAMING_SNAKE_CASE_          =  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
        SCREAMING_SNAKE_CASE_          =  outputs.class_queries_logits
        self.assertEqual(
            class_queries_logits.shape  ,     (1, model.config.decoder_config.num_queries, model.config.num_labels + 1)   )
        SCREAMING_SNAKE_CASE_          =  torch.tensor(
            [
                [1.6512e00, -5.2572e00, -3.3519e00],
                [3.6169e-02, -5.9025e00, -2.9313e00],
                [1.0766e-04, -7.7630e00, -5.1263e00],
            ]   ).to(__magic_name__   )
        self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]  ,     __magic_name__  ,     atol=__magic_name__   )   )







  def    __A     (							self :       Any   )  ->	Any:
        SCREAMING_SNAKE_CASE_          =  (
            MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-resnet101-coco-stuff"   )
            .to(__magic_name__   )
            .eval()
        )
        SCREAMING_SNAKE_CASE_          =  self.default_image_processor
        SCREAMING_SNAKE_CASE_          =  prepare_img()
        SCREAMING_SNAKE_CASE_          =  image_processor(__magic_name__  ,     return_tensors="pt"   ).to(__magic_name__   )
        SCREAMING_SNAKE_CASE_          =  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, 800, 1_088)   )

        with torch.no_grad():
              SCREAMING_SNAKE_CASE_          =  model(**__magic_name__   )
        # masks_queries_logits
        SCREAMING_SNAKE_CASE_          =  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)  ,     )
        SCREAMING_SNAKE_CASE_          =  [[-0.9046, -2.6366, -4.6062], [-3.4179, -5.7890, -8.8057], [-4.9179, -7.6560, -10.7711]]
        SCREAMING_SNAKE_CASE_          =  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
        SCREAMING_SNAKE_CASE_          =  outputs.class_queries_logits
        self.assertEqual(
            class_queries_logits.shape  ,     (1, model.config.decoder_config.num_queries, model.config.num_labels + 1)   )
        SCREAMING_SNAKE_CASE_          =  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    __A     (							self :       int   )  ->	Tuple:
        SCREAMING_SNAKE_CASE_          =  (
            MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco"   )
            .to(__magic_name__   )
            .eval()
        )
        SCREAMING_SNAKE_CASE_          =  self.default_image_processor

        SCREAMING_SNAKE_CASE_          =  image_processor(
            [np.zeros((3, 800, 1_333)   ), np.zeros((3, 800, 1_333)   )]  ,     segmentation_maps=[np.zeros((384, 384)   ).astype(np.floataa   ), np.zeros((384, 384)   ).astype(np.floataa   )]  ,     return_tensors="pt"  ,     )

        SCREAMING_SNAKE_CASE_          =  inputs["pixel_values"].to(__magic_name__   )
        SCREAMING_SNAKE_CASE_          =  [el.to(__magic_name__   ) for el in inputs["mask_labels"]]
        SCREAMING_SNAKE_CASE_          =  [el.to(__magic_name__   ) for el in inputs["class_labels"]]

        with torch.no_grad():
              SCREAMING_SNAKE_CASE_          =  model(**__magic_name__   )

        self.assertTrue(outputs.loss is not None   )



from math import factorial


def      a__ (		__UpperCamelCase = 1_0_0				):
      return sum(int(__UpperCamelCase				) for x in str(factorial(__UpperCamelCase				)				)				)


if __name__ == "__main__":
      print(solution(int(input("Enter the Number: ").strip())))


