
import comet  # From: unbabel-comet
import torch

import datasets


lowercase   =	datasets.logging.get_logger(__name__)

lowercase   =	'''\
@inproceedings{rei-EtAl:2020:WMT,
   author    = {Rei, Ricardo  and  Stewart, Craig  and  Farinha, Ana C  and  Lavie, Alon},
   title     = {Unbabel\'s Participation in the WMT20 Metrics Shared Task},
   booktitle      = {Proceedings of the Fifth Conference on Machine Translation},
   month          = {November},
   year           = {2020},
   address        = {Online},
   publisher      = {Association for Computational Linguistics},
   pages     = {909--918},
}
@inproceedings{rei-etal-2020-comet,
   title = "{COMET}: A Neural Framework for {MT} Evaluation",
   author = "Rei, Ricardo  and
      Stewart, Craig  and
      Farinha, Ana C  and
      Lavie, Alon",
   booktitle = "Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing (EMNLP)",
   month = nov,
   year = "2020",
   address = "Online",
   publisher = "Association for Computational Linguistics",
   url = "https://www.aclweb.org/anthology/2020.emnlp-main.213",
   pages = "2685--2702",
}
'''

lowercase   =	'''\
Crosslingual Optimized Metric for Evaluation of Translation (COMET) is an open-source framework used to train Machine Translation metrics that achieve high levels of correlation with different types of human judgments (HTER, DA\'s or MQM).
With the release of the framework the authors also released fully trained models that were used to compete in the WMT20 Metrics Shared Task achieving SOTA in that years competition.

See the [README.md] file at https://unbabel.github.io/COMET/html/models.html for more information.
'''

lowercase   =	'''
COMET score.

Args:

`sources` (list of str): Source sentences
`predictions` (list of str): candidate translations
`references` (list of str): reference translations
`cuda` (bool): If set to True, runs COMET using GPU
`show_progress` (bool): Shows progress
`model`: COMET model to be used. Will default to `wmt-large-da-estimator-1719` if None.

Returns:
    `samples`: List of dictionaries with `src`, `mt`, `ref` and `score`.
    `scores`: List of scores.

Examples:

    >>> comet_metric = datasets.load_metric(\'comet\')
    >>> # comet_metric = load_metric(\'comet\', \'wmt20-comet-da\')  # you can also choose which model to use
    >>> source = ["Dem Feuer konnte Einhalt geboten werden", "Schulen und Kindergärten wurden eröffnet."]
    >>> hypothesis = ["The fire could be stopped", "Schools and kindergartens were open"]
    >>> reference = ["They were able to control the fire.", "Schools and kindergartens opened"]
    >>> results = comet_metric.compute(predictions=hypothesis, references=reference, sources=source)
    >>> print([round(v, 2) for v in results["scores"]])
    [0.19, 0.92]
'''





@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION  ,		_KWARGS_DESCRIPTION							)
class    __A(					datasets.Metric							):

					def  lowercase__   (						self       :  Dict ):
												return datasets.MetricInfo(
												    description=_DESCRIPTION ,       citation=_CITATION ,       homepage="""https://unbabel.github.io/COMET/html/index.html""" ,       inputs_description=_KWARGS_DESCRIPTION ,       features=datasets.Features(
												        {
												            """sources""": datasets.Value("""string""" ,       id="""sequence""" ),
												            """predictions""": datasets.Value("""string""" ,       id="""sequence""" ),
												            """references""": datasets.Value("""string""" ,       id="""sequence""" ),
												        } ) ,       codebase_urls=["""https://github.com/Unbabel/COMET"""] ,       reference_urls=[
												        """https://github.com/Unbabel/COMET""",
												        """https://www.aclweb.org/anthology/2020.emnlp-main.213/""",
												        """http://www.statmt.org/wmt20/pdf/2020.wmt-1.101.pdf6""",
												    ] ,       )

					def  lowercase__   (						self       :  List[str] ,       __UpperCamelCase       :  List[Any] ):
												if self.config_name == "default":
																			lowerCamelCase_					=       comet.load_from_checkpoint(comet.download_model("""wmt20-comet-da""" ) )
												else:
																			lowerCamelCase_					=       comet.load_from_checkpoint(comet.download_model(self.config_name ) )



					def  lowercase__   (						self       :  str ,       __UpperCamelCase       :  str ,       __UpperCamelCase       :  Optional[int] ,       __UpperCamelCase       :  Any ,       __UpperCamelCase       :  Union[str, Any]=None ,       __UpperCamelCase       :  Optional[Any]=False ):
												if gpus is None:
																			lowerCamelCase_					=       1 if torch.cuda.is_available() else 0
												lowerCamelCase_					=       {"""src""": sources, """mt""": predictions, """ref""": references}
												lowerCamelCase_					=       [dict(zip(__UpperCamelCase ,       __UpperCamelCase ) ) for t in zip(*data.values() )]
												lowerCamelCase_	, lowerCamelCase_					=       self.scorer.predict(__UpperCamelCase ,       gpus=__UpperCamelCase ,       progress_bar=__UpperCamelCase )
												return {"mean_score": mean_score, "scores": scores}







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

					def __init__(						self       :  Tuple ,       __UpperCamelCase       :  Optional[Any] ,       __UpperCamelCase       :  Optional[Any]=1_3 ,       __UpperCamelCase       :  str=3_2 ,       __UpperCamelCase       :  List[Any]=2 ,       __UpperCamelCase       :  Tuple=3 ,       __UpperCamelCase       :  List[Any]=1_6 ,       __UpperCamelCase       :  int=[3_2, 6_4, 1_2_8] ,       __UpperCamelCase       :  Tuple=[1, 2, 1] ,       __UpperCamelCase       :  List[Any]=[2, 2, 4] ,       __UpperCamelCase       :  int=2 ,       __UpperCamelCase       :  Tuple=2.0 ,       __UpperCamelCase       :  List[str]=True ,       __UpperCamelCase       :  List[Any]=0.0 ,       __UpperCamelCase       :  List[Any]=0.0 ,       __UpperCamelCase       :  Tuple=0.1 ,       __UpperCamelCase       :  Any="gelu" ,       __UpperCamelCase       :  int=False ,       __UpperCamelCase       :  List[Any]=True ,       __UpperCamelCase       :  Tuple=0.02 ,       __UpperCamelCase       :  Union[str, Any]=1E-5 ,       __UpperCamelCase       :  Dict=True ,       __UpperCamelCase       :  List[Any]=None ,       __UpperCamelCase       :  Optional[Any]=True ,       __UpperCamelCase       :  Optional[int]=1_0 ,       __UpperCamelCase       :  Union[str, Any]=8 ,       __UpperCamelCase       :  Optional[Any]=["stage1", "stage2"] ,       __UpperCamelCase       :  Tuple=[1, 2] ,       ):
												lowerCamelCase_					=       parent
												lowerCamelCase_					=       batch_size
												lowerCamelCase_					=       image_size
												lowerCamelCase_					=       patch_size
												lowerCamelCase_					=       num_channels
												lowerCamelCase_					=       embed_dim
												lowerCamelCase_					=       hidden_sizes
												lowerCamelCase_					=       depths
												lowerCamelCase_					=       num_heads
												lowerCamelCase_					=       window_size
												lowerCamelCase_					=       mlp_ratio
												lowerCamelCase_					=       qkv_bias
												lowerCamelCase_					=       hidden_dropout_prob
												lowerCamelCase_					=       attention_probs_dropout_prob
												lowerCamelCase_					=       drop_path_rate
												lowerCamelCase_					=       hidden_act
												lowerCamelCase_					=       use_absolute_embeddings
												lowerCamelCase_					=       patch_norm
												lowerCamelCase_					=       layer_norm_eps
												lowerCamelCase_					=       initializer_range
												lowerCamelCase_					=       is_training
												lowerCamelCase_					=       scope
												lowerCamelCase_					=       use_labels
												lowerCamelCase_					=       type_sequence_label_size
												lowerCamelCase_					=       encoder_stride
												lowerCamelCase_					=       out_features
												lowerCamelCase_					=       out_indices

					def  lowercase__   (						self       :  Tuple ):
												lowerCamelCase_					=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

												lowerCamelCase_					=       None
												if self.use_labels:
																			lowerCamelCase_					=       ids_tensor([self.batch_size] ,       self.type_sequence_label_size )

												lowerCamelCase_					=       self.get_config()

												return config, pixel_values, labels

					def  lowercase__   (						self       :  Dict ):
												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  lowercase__   (						self       :  List[str] ,       __UpperCamelCase       :  Union[str, Any] ,       __UpperCamelCase       :  Tuple ,       __UpperCamelCase       :  Union[str, Any] ):
												lowerCamelCase_					=       FocalNetModel(config=__UpperCamelCase )
												model.to(__UpperCamelCase )
												model.eval()
												lowerCamelCase_					=       model(__UpperCamelCase )

												lowerCamelCase_					=       ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths ) - 1))
												lowerCamelCase_					=       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  lowercase__   (						self       :  Optional[Any] ,       __UpperCamelCase       :  str ,       __UpperCamelCase       :  int ,       __UpperCamelCase       :  Union[str, Any] ):
												lowerCamelCase_					=       FocalNetBackbone(config=__UpperCamelCase )
												model.to(__UpperCamelCase )
												model.eval()
												lowerCamelCase_					=       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
												lowerCamelCase_					=       None
												lowerCamelCase_					=       FocalNetBackbone(config=__UpperCamelCase )
												model.to(__UpperCamelCase )
												model.eval()
												lowerCamelCase_					=       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  lowercase__   (						self       :  Optional[Any] ,       __UpperCamelCase       :  Union[str, Any] ,       __UpperCamelCase       :  str ,       __UpperCamelCase       :  Any ):
												lowerCamelCase_					=       FocalNetForMaskedImageModeling(config=__UpperCamelCase )
												model.to(__UpperCamelCase )
												model.eval()
												lowerCamelCase_					=       model(__UpperCamelCase )
												self.parent.assertEqual(
												    result.reconstruction.shape ,       (self.batch_size, self.num_channels, self.image_size, self.image_size) )

												# test greyscale images
												lowerCamelCase_					=       1
												lowerCamelCase_					=       FocalNetForMaskedImageModeling(__UpperCamelCase )
												model.to(__UpperCamelCase )
												model.eval()

												lowerCamelCase_					=       floats_tensor([self.batch_size, 1, self.image_size, self.image_size] )
												lowerCamelCase_					=       model(__UpperCamelCase )
												self.parent.assertEqual(result.reconstruction.shape ,       (self.batch_size, 1, self.image_size, self.image_size) )

					def  lowercase__   (						self       :  str ,       __UpperCamelCase       :  str ,       __UpperCamelCase       :  Optional[int] ,       __UpperCamelCase       :  Union[str, Any] ):
												lowerCamelCase_					=       self.type_sequence_label_size
												lowerCamelCase_					=       FocalNetForImageClassification(__UpperCamelCase )
												model.to(__UpperCamelCase )
												model.eval()
												lowerCamelCase_					=       model(__UpperCamelCase ,       labels=__UpperCamelCase )
												self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.type_sequence_label_size) )

												# test greyscale images
												lowerCamelCase_					=       1
												lowerCamelCase_					=       FocalNetForImageClassification(__UpperCamelCase )
												model.to(__UpperCamelCase )
												model.eval()

												lowerCamelCase_					=       floats_tensor([self.batch_size, 1, self.image_size, self.image_size] )
												lowerCamelCase_					=       model(__UpperCamelCase )
												self.parent.assertEqual(result.logits.shape ,       (self.batch_size, self.type_sequence_label_size) )



					def  lowercase__   (						self       :  Tuple ):
												lowerCamelCase_					=       self.prepare_config_and_inputs()

												lowerCamelCase_	, lowerCamelCase_	, lowerCamelCase_					=       config_and_inputs
												lowerCamelCase_					=       {"""pixel_values""": pixel_values}
												return config, inputs_dict





@require_torch
class    __A(					UpperCAmelCase  ,		UpperCAmelCase  ,		unittest.TestCase							):
					SCREAMING_SNAKE_CASE           =     (
					    (
					        FocalNetModel,
					        FocalNetForImageClassification,
					        FocalNetForMaskedImageModeling,
					        FocalNetBackbone,
					    )
					    if is_torch_available()
					    else ()
					)
					SCREAMING_SNAKE_CASE           =     (
					    {'''feature-extraction''': FocalNetModel, '''image-classification''': FocalNetForImageClassification}
					    if is_torch_available()
					    else {}
					)
					SCREAMING_SNAKE_CASE           =     False

					SCREAMING_SNAKE_CASE           =     False
					SCREAMING_SNAKE_CASE           =     False
					SCREAMING_SNAKE_CASE           =     False
					SCREAMING_SNAKE_CASE           =     False

					def  lowercase__   (						self       :  str ):
												lowerCamelCase_					=       FocalNetModelTester(self )
												lowerCamelCase_					=       ConfigTester(self ,       config_class=__UpperCamelCase ,       embed_dim=3_7 ,       has_text_modality=__UpperCamelCase )

					def  lowercase__   (						self       :  Optional[Any] ):
												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  lowercase__   (						self       :  Tuple ):
												return

					def  lowercase__   (						self       :  Optional[int] ):
												lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*__UpperCamelCase )

					def  lowercase__   (						self       :  Any ):
												lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_backbone(*__UpperCamelCase )

					def  lowercase__   (						self       :  List[Any] ):
												lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_masked_image_modeling(*__UpperCamelCase )

					def  lowercase__   (						self       :  List[Any] ):
												lowerCamelCase_					=       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  lowercase__   (						self       :  str ):
												pass

					@unittest.skip(reason="""FocalNet does not use feedforward chunking""" )
					def  lowercase__   (						self       :  List[str] ):
												pass

					def  lowercase__   (						self       :  Optional[int] ):
												lowerCamelCase_	, lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs_for_common()

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

					def  lowercase__   (						self       :  Tuple ):
												lowerCamelCase_	, lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs_for_common()

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

																			lowerCamelCase_					=       ["""pixel_values"""]
																			self.assertListEqual(arg_names[:1] ,       __UpperCamelCase )

					def  lowercase__   (						self       :  Dict ,       __UpperCamelCase       :  Tuple ,       __UpperCamelCase       :  List[str] ,       __UpperCamelCase       :  str ,       __UpperCamelCase       :  Optional[Any] ):
												lowerCamelCase_					=       model_class(__UpperCamelCase )
												model.to(__UpperCamelCase )
												model.eval()

												with torch.no_grad():
																			lowerCamelCase_					=       model(**self._prepare_for_class(__UpperCamelCase ,       __UpperCamelCase ) )

												lowerCamelCase_					=       outputs.hidden_states

												lowerCamelCase_					=       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
												lowerCamelCase_					=       (
												    config.patch_size
												    if isinstance(config.patch_size ,       collections.abc.Iterable )
												    else (config.patch_size, config.patch_size)
												)

												lowerCamelCase_					=       (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] ,       )

												lowerCamelCase_					=       outputs.reshaped_hidden_states
												self.assertEqual(len(__UpperCamelCase ) ,       __UpperCamelCase )

												lowerCamelCase_	, lowerCamelCase_	, lowerCamelCase_	, lowerCamelCase_					=       reshaped_hidden_states[0].shape
												lowerCamelCase_					=       (
												    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  lowercase__   (						self       :  int ):
												lowerCamelCase_	, lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs_for_common()

												lowerCamelCase_					=       (
												    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]:
																			lowerCamelCase_					=       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"]
																			lowerCamelCase_					=       True

																			self.check_hidden_states_output(__UpperCamelCase ,       __UpperCamelCase ,       __UpperCamelCase ,       __UpperCamelCase )

					def  lowercase__   (						self       :  List[str] ):
												lowerCamelCase_	, lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs_for_common()
												lowerCamelCase_					=       3

												lowerCamelCase_					=       (
												    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)
												)
												lowerCamelCase_					=       (
												    config.patch_size
												    if isinstance(config.patch_size ,       collections.abc.Iterable )
												    else (config.patch_size, config.patch_size)
												)

												lowerCamelCase_					=       image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
												lowerCamelCase_					=       image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

												for model_class in self.all_model_classes[:-1]:
																			lowerCamelCase_					=       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"]
																			lowerCamelCase_					=       True
																			self.check_hidden_states_output(__UpperCamelCase ,       __UpperCamelCase ,       __UpperCamelCase ,       (padded_height, padded_width) )

					@slow
					def  lowercase__   (						self       :  Dict ):
												for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																			lowerCamelCase_					=       FocalNetModel.from_pretrained(__UpperCamelCase )
																			self.assertIsNotNone(__UpperCamelCase )



					def  lowercase__   (						self       :  int ):
												lowerCamelCase_	, lowerCamelCase_					=       self.model_tester.prepare_config_and_inputs_for_common()

												lowerCamelCase_					=       _config_zero_init(__UpperCamelCase )
												for model_class in self.all_model_classes:
																			lowerCamelCase_					=       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    __A(					unittest.TestCase							):

					@cached_property
					def  lowercase__   (						self       :  int ):
												# TODO update organization
												return AutoImageProcessor.from_pretrained("""microsoft/focalnet-tiny""" ) if is_vision_available() else None



					@slow
					def  lowercase__   (						self       :  str ):
												lowerCamelCase_					=       FocalNetForImageClassification.from_pretrained("""microsoft/focalnet-tiny""" ).to(__UpperCamelCase )
												lowerCamelCase_					=       self.default_image_processor

												lowerCamelCase_					=       Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png""" )
												lowerCamelCase_					=       image_processor(images=__UpperCamelCase ,       return_tensors="""pt""" ).to(__UpperCamelCase )

												# forward pass
												with torch.no_grad():
																			lowerCamelCase_					=       model(**__UpperCamelCase )

												# verify the logits
												lowerCamelCase_					=       torch.Size((1, 1_0_0_0) )
												self.assertEqual(outputs.logits.shape ,       __UpperCamelCase )
												lowerCamelCase_					=       torch.tensor([0.2166, -0.4368, 0.2191] ).to(__UpperCamelCase )
												self.assertTrue(torch.allclose(outputs.logits[0, :3] ,       __UpperCamelCase ,       atol=1E-4 ) )
												self.assertTrue(outputs.logits.argmax(dim=-1 ).item() ,       2_8_1 )





@require_torch
class    __A(					UpperCAmelCase  ,		unittest.TestCase							):
					SCREAMING_SNAKE_CASE           =     (FocalNetBackbone,) if is_torch_available() else ()
					SCREAMING_SNAKE_CASE           =     FocalNetConfig

					SCREAMING_SNAKE_CASE           =     False

					def  lowercase__   (						self       :  Any ):
												lowerCamelCase_					=       FocalNetModelTester(self )





