




import math







def SCREAMING_SNAKE_CASE       ( lowercase_		)     -> int:



       """simple docstring"""

       if not isinstance(lowercase_				,       lowercase_		):
              A__   				=					f"""Input value of [number={number}] must be an integer"""
              raise TypeError(lowercase_		)

       if number < 1:
              A__   				=					f"""Input value of [number={number}] must be > 0"""
              raise ValueError(lowercase_		)
       elif number == 1:
              return 3
       elif number == 2:
              return 5
       else:
              A__   				=					int(math.log(number // 3				,       2		)		) + 2

              A__   				=					[3, 5]
              A__   				=					2
              A__   				=					3
              for block in range(1				,       lowercase_		):
                     for _ in range(lowercase_		):
                            proth_list.append(2 ** (block + 1) + proth_list[proth_index - 1]		)
                            proth_index += 1
                     increment *= 2

       return proth_list[number - 1]


if __name__ == "__main__":
  import doctest

  doctest.testmod()

  for number in range(11):
    _lowerCamelCase			:	List[str]							 =     0
    try:
      _lowerCamelCase			:	Union[str, Any]							 =     proth(number)
    except ValueError:
      print(F'''ValueError: there is no {number}th Proth number''')
      continue

    print(F'''The {number}th Proth number: {value}''')








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        UpperCamelCase_					:

    '''simple docstring'''






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





           '''simple docstring'''

           A__   				=					parent
           A__   				=					batch_size
           A__   				=					is_training
           A__   				=					use_auxiliary_loss
           A__   				=					num_queries
           A__   				=					num_channels
           A__   				=					min_size
           A__   				=					max_size
           A__   				=					num_labels
           A__   				=					mask_feature_size


    def  SCREAMING_SNAKE_CASE							(    self   :			Dict)		->int:





           '''simple docstring'''

           A__   				=					floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]).to(
               UpperCAmelCase__)

           A__   				=					torch.ones([self.batch_size, self.min_size, self.max_size]      ,				device=UpperCAmelCase__)

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

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


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





           '''simple docstring'''

           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  SCREAMING_SNAKE_CASE							(    self   :			Union[str, Any])		->List[Any]:





           '''simple docstring'''

           A__				,							A__				,							A__				,							A__				,							A__   				=					self.prepare_config_and_inputs()
           A__   				=					{'''pixel_values''': pixel_values, '''pixel_mask''': pixel_mask}
           return config, inputs_dict


    def  SCREAMING_SNAKE_CASE							(    self   :			Tuple      ,				UpperCAmelCase__   :			Optional[int]      ,				UpperCAmelCase__   :			List[Any])		->int:





           '''simple docstring'''

           A__   				=					output.encoder_hidden_states
           A__   				=					output.pixel_decoder_hidden_states
           A__   				=					output.transformer_decoder_hidden_states

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


    def  SCREAMING_SNAKE_CASE							(    self   :			Optional[Any]      ,				UpperCAmelCase__   :			Optional[Any]      ,				UpperCAmelCase__   :			Union[str, Any]      ,				UpperCAmelCase__   :			Union[str, Any]      ,				UpperCAmelCase__   :			Optional[Any]=False)		->Optional[int]:





           '''simple docstring'''

           with torch.no_grad():
                  A__   				=					MaskFormerModel(config=UpperCAmelCase__)
                  model.to(UpperCAmelCase__)
                  model.eval()

                  A__   				=					model(pixel_values=UpperCAmelCase__      ,				pixel_mask=UpperCAmelCase__)
                  A__   				=					model(UpperCAmelCase__      ,				output_hidden_states=UpperCAmelCase__)
           # 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(UpperCAmelCase__      ,				UpperCAmelCase__)





    def  SCREAMING_SNAKE_CASE							(    self   :			str      ,				UpperCAmelCase__   :			Tuple      ,				UpperCAmelCase__   :			Optional[int]      ,				UpperCAmelCase__   :			List[str]      ,				UpperCAmelCase__   :			int      ,				UpperCAmelCase__   :			int)		->List[Any]:





           '''simple docstring'''

           A__   				=					MaskFormerForInstanceSegmentation(config=UpperCAmelCase__)
           model.to(UpperCAmelCase__)
           model.eval()

           def comm_check_on_output(UpperCAmelCase__   :			str):
                  # 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():
                  A__   				=					model(pixel_values=UpperCAmelCase__      ,				pixel_mask=UpperCAmelCase__)
                  A__   				=					model(UpperCAmelCase__)

                  comm_check_on_output(UpperCAmelCase__)

                  A__   				=					model(
                      pixel_values=UpperCAmelCase__      ,				pixel_mask=UpperCAmelCase__      ,				mask_labels=UpperCAmelCase__      ,				class_labels=UpperCAmelCase__)

           comm_check_on_output(UpperCAmelCase__)

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


@require_torch
class        UpperCamelCase_					(				UpperCAmelCase__	,      UpperCAmelCase__	,      unittest.TestCase  ):

    '''simple docstring'''






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

    UpperCAmelCase__													=   False
    UpperCAmelCase__													=   False
    UpperCAmelCase__													=   False
    UpperCAmelCase__													=   False


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





           '''simple docstring'''

           A__   				=					MaskFormerModelTester(self)
           A__   				=					ConfigTester(self      ,				config_class=UpperCAmelCase__      ,				has_text_modality=UpperCAmelCase__)


    def  SCREAMING_SNAKE_CASE							(    self   :			List[Any])		->Tuple:





           '''simple docstring'''

           self.config_tester.run_common_tests()


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





           '''simple docstring'''

           A__				,							A__   				=					self.model_tester.prepare_config_and_inputs_for_common()
           self.model_tester.create_and_check_maskformer_model(UpperCAmelCase__      ,				**UpperCAmelCase__      ,				output_hidden_states=UpperCAmelCase__)


    def  SCREAMING_SNAKE_CASE							(    self   :			str)		->Any:





           '''simple docstring'''

           A__   				=					self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_maskformer_instance_segmentation_head_model(*UpperCAmelCase__)


    @unittest.skip(reason='''MaskFormer does not use inputs_embeds''')
    def  SCREAMING_SNAKE_CASE							(    self   :			Dict)		->Tuple:





           '''simple docstring'''

           pass


    @unittest.skip(reason='''MaskFormer does not have a get_input_embeddings method''')
    def  SCREAMING_SNAKE_CASE							(    self   :			Optional[int])		->Union[str, Any]:





           '''simple docstring'''

           pass


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





           '''simple docstring'''

           pass


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





           '''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  SCREAMING_SNAKE_CASE							(    self   :			Optional[int])		->Optional[int]:





           '''simple docstring'''

           pass


    @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.''')
    def  SCREAMING_SNAKE_CASE							(    self   :			Tuple)		->Dict:





           '''simple docstring'''

           pass


    def  SCREAMING_SNAKE_CASE							(    self   :			Dict)		->Dict:





           '''simple docstring'''

           A__				,							A__   				=					self.model_tester.prepare_config_and_inputs_for_common()

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

                  A__   				=					['''pixel_values''']
                  self.assertListEqual(arg_names[:1]      ,				UpperCAmelCase__)


    @slow
    def  SCREAMING_SNAKE_CASE							(    self   :			Any)		->Optional[Any]:





           '''simple docstring'''

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


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





           '''simple docstring'''

           A__   				=					(self.model_tester.min_size,) * 2
           A__   				=					{
               '''pixel_values''': torch.randn((2, 3, *size)      ,				device=UpperCAmelCase__),
               '''mask_labels''': torch.randn((2, 10, *size)      ,				device=UpperCAmelCase__),
               '''class_labels''': torch.zeros(2      ,				10      ,				device=UpperCAmelCase__).long(),
           }

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


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





           '''simple docstring'''

           A__				,							A__   				=					self.model_tester.prepare_config_and_inputs_for_common()
           self.model_tester.create_and_check_maskformer_model(UpperCAmelCase__      ,				**UpperCAmelCase__      ,				output_hidden_states=UpperCAmelCase__)


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





           '''simple docstring'''

           A__				,							A__   				=					self.model_tester.prepare_config_and_inputs_for_common()

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


    def  SCREAMING_SNAKE_CASE							(    self   :			List[Any])		->Union[str, Any]:





           '''simple docstring'''

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

           A__   				=					model_class(UpperCAmelCase__)
           model.to(UpperCAmelCase__)
           model.train()

           A__   				=					model(UpperCAmelCase__      ,				mask_labels=UpperCAmelCase__      ,				class_labels=UpperCAmelCase__).loss
           loss.backward()





    def  SCREAMING_SNAKE_CASE							(    self   :			int)		->str:





           '''simple docstring'''

           A__   				=					self.all_model_classes[1]
           A__				,							A__				,							A__				,							A__				,							A__   				=					self.model_tester.prepare_config_and_inputs()
           A__   				=					True
           A__   				=					True

           A__   				=					model_class(UpperCAmelCase__)
           model.to(UpperCAmelCase__)
           model.train()

           A__   				=					model(UpperCAmelCase__      ,				mask_labels=UpperCAmelCase__      ,				class_labels=UpperCAmelCase__)

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

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

           A__   				=					outputs.attentions[0]
           attentions.retain_grad()

           outputs.loss.backward(retain_graph=UpperCAmelCase__)

           self.assertIsNotNone(encoder_hidden_states.grad)
           self.assertIsNotNone(pixel_decoder_hidden_states.grad)
           self.assertIsNotNone(transformer_decoder_hidden_states.grad)
           self.assertIsNotNone(attentions.grad)
_lowerCamelCase			:	Tuple							 =     1E-4







def SCREAMING_SNAKE_CASE       ( )     -> int:



       """simple docstring"""

       A__   				=					Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''		)
       return image


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

    '''simple docstring'''






    @cached_property
    def  SCREAMING_SNAKE_CASE							(    self   :			Tuple)		->List[str]:





           '''simple docstring'''

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


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





           '''simple docstring'''

           A__   				=					MaskFormerModel.from_pretrained('''facebook/maskformer-swin-small-coco''').to(UpperCAmelCase__)
           A__   				=					self.default_image_processor
           A__   				=					prepare_img()
           A__   				=					image_processor(UpperCAmelCase__      ,				return_tensors='''pt''').to(UpperCAmelCase__)
           A__   				=					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(UpperCAmelCase__      ,				(1, 3, 800, 1_088))

           with torch.no_grad():
                  A__   				=					model(**UpperCAmelCase__)

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

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

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


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





           '''simple docstring'''

           A__   				=					(
               MaskFormerForInstanceSegmentation.from_pretrained('''facebook/maskformer-swin-small-coco''')
               .to(UpperCAmelCase__)
               .eval()
           )
           A__   				=					self.default_image_processor
           A__   				=					prepare_img()
           A__   				=					image_processor(UpperCAmelCase__      ,				return_tensors='''pt''').to(UpperCAmelCase__)
           A__   				=					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(UpperCAmelCase__      ,				(1, 3, 800, 1_088))

           with torch.no_grad():
                  A__   				=					model(**UpperCAmelCase__)
           # masks_queries_logits
           A__   				=					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)      ,				)
           A__   				=					[
               [-1.3737124, -1.7724937, -1.9364233],
               [-1.5977281, -1.9867939, -2.1523695],
               [-1.5795398, -1.9269832, -2.093942],
           ]
           A__   				=					torch.tensor(UpperCAmelCase__).to(UpperCAmelCase__)
           self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]      ,				UpperCAmelCase__      ,				atol=UpperCAmelCase__))
           # class_queries_logits
           A__   				=					outputs.class_queries_logits
           self.assertEqual(
               class_queries_logits.shape      ,				(1, model.config.decoder_config.num_queries, model.config.num_labels + 1))
           A__   				=					torch.tensor(
               [
                   [1.65_12e00, -5.25_72e00, -3.35_19e00],
                   [3.61_69e-02, -5.90_25e00, -2.93_13e00],
                   [1.07_66e-04, -7.76_30e00, -5.12_63e00],
               ]).to(UpperCAmelCase__)
           self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]      ,				UpperCAmelCase__      ,				atol=UpperCAmelCase__))


    def  SCREAMING_SNAKE_CASE							(    self   :			str)		->Optional[Any]:





           '''simple docstring'''

           A__   				=					(
               MaskFormerForInstanceSegmentation.from_pretrained('''facebook/maskformer-resnet101-coco-stuff''')
               .to(UpperCAmelCase__)
               .eval()
           )
           A__   				=					self.default_image_processor
           A__   				=					prepare_img()
           A__   				=					image_processor(UpperCAmelCase__      ,				return_tensors='''pt''').to(UpperCAmelCase__)
           A__   				=					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(UpperCAmelCase__      ,				(1, 3, 800, 1_088))

           with torch.no_grad():
                  A__   				=					model(**UpperCAmelCase__)
           # masks_queries_logits
           A__   				=					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)      ,				)
           A__   				=					[[-0.9046, -2.6366, -4.6062], [-3.4179, -5.7890, -8.8057], [-4.9179, -7.6560, -10.7711]]
           A__   				=					torch.tensor(UpperCAmelCase__).to(UpperCAmelCase__)
           self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]      ,				UpperCAmelCase__      ,				atol=UpperCAmelCase__))
           # class_queries_logits
           A__   				=					outputs.class_queries_logits
           self.assertEqual(
               class_queries_logits.shape      ,				(1, model.config.decoder_config.num_queries, model.config.num_labels + 1))
           A__   				=					torch.tensor(
               [[4.7188, -3.2585, -2.8857], [6.6871, -2.9181, -1.2487], [7.2449, -2.2764, -2.1874]]).to(UpperCAmelCase__)
           self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]      ,				UpperCAmelCase__      ,				atol=UpperCAmelCase__))





    def  SCREAMING_SNAKE_CASE							(    self   :			Dict)		->Dict:





           '''simple docstring'''

           A__   				=					(
               MaskFormerForInstanceSegmentation.from_pretrained('''facebook/maskformer-swin-small-coco''')
               .to(UpperCAmelCase__)
               .eval()
           )
           A__   				=					self.default_image_processor

           A__   				=					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'''      ,				)

           A__   				=					inputs['''pixel_values'''].to(UpperCAmelCase__)
           A__   				=					[el.to(UpperCAmelCase__) for el in inputs['''mask_labels''']]
           A__   				=					[el.to(UpperCAmelCase__) for el in inputs['''class_labels''']]

           with torch.no_grad():
                  A__   				=					model(**UpperCAmelCase__)

           self.assertTrue(outputs.loss is not None)


