




import shutil
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartTokenizer, MBartTokenizerFast, is_torch_available
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


_A     =			get_tests_dir('''fixtures/test_sentencepiece.model''')


if is_torch_available():
						from transformers.models.mbart.modeling_mbart import shift_tokens_right

_A     =			250_004
_A     =			250_020


@require_sentencepiece
@require_tokenizers
class  A		(  __UpperCAmelCase      ,				unittest.TestCase     ):
		__snake_case									=   MBartTokenizer
		__snake_case									=   MBartTokenizerFast
		__snake_case									=   True
		__snake_case									=   True



		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								super().setUp()

								# We have a SentencePiece fixture for testing
								lowerCAmelCase_      			=  MBartTokenizer(UpperCamelCase__,	keep_accents=UpperCamelCase__   )
								tokenizer.save_pretrained(self.tmpdirname   )



		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  MBartTokenizer(UpperCamelCase__,	keep_accents=UpperCamelCase__   )

								lowerCAmelCase_      			=  tokenizer.tokenize('''This is a test'''   )
								self.assertListEqual(UpperCamelCase__,	['''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']   )

								self.assertListEqual(
								    tokenizer.convert_tokens_to_ids(UpperCamelCase__   ),	[value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]],	)

								lowerCAmelCase_      			=  tokenizer.tokenize('''I was born in 92000, and this is falsé.'''   )
								self.assertListEqual(
								    UpperCamelCase__,	[
								        SPIECE_UNDERLINE + '''I''',
								        SPIECE_UNDERLINE + '''was''',
								        SPIECE_UNDERLINE + '''b''',
								        '''or''',
								        '''n''',
								        SPIECE_UNDERLINE + '''in''',
								        SPIECE_UNDERLINE + '''''',
								        '''9''',
								        '''2''',
								        '''0''',
								        '''0''',
								        '''0''',
								        ''',''',
								        SPIECE_UNDERLINE + '''and''',
								        SPIECE_UNDERLINE + '''this''',
								        SPIECE_UNDERLINE + '''is''',
								        SPIECE_UNDERLINE + '''f''',
								        '''al''',
								        '''s''',
								        '''é''',
								        '''.''',
								    ],	)
								lowerCAmelCase_      			=  tokenizer.convert_tokens_to_ids(UpperCamelCase__   )
								self.assertListEqual(
								    UpperCamelCase__,	[
								        value + tokenizer.fairseq_offset
								        for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
								        #                                       ^ unk: 2 + 1 = 3                  unk: 2 + 1 = 3 ^
								    ],	)

								lowerCAmelCase_      			=  tokenizer.convert_ids_to_tokens(UpperCamelCase__   )
								self.assertListEqual(
								    UpperCamelCase__,	[
								        SPIECE_UNDERLINE + '''I''',
								        SPIECE_UNDERLINE + '''was''',
								        SPIECE_UNDERLINE + '''b''',
								        '''or''',
								        '''n''',
								        SPIECE_UNDERLINE + '''in''',
								        SPIECE_UNDERLINE + '''''',
								        '''<unk>''',
								        '''2''',
								        '''0''',
								        '''0''',
								        '''0''',
								        ''',''',
								        SPIECE_UNDERLINE + '''and''',
								        SPIECE_UNDERLINE + '''this''',
								        SPIECE_UNDERLINE + '''is''',
								        SPIECE_UNDERLINE + '''f''',
								        '''al''',
								        '''s''',
								        '''<unk>''',
								        '''.''',
								    ],	)







		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								if not self.test_slow_tokenizer:
														# as we don't have a slow version, we can't compare the outputs between slow and fast versions
														return

								lowerCAmelCase_      			=  (self.rust_tokenizer_class, '''hf-internal-testing/tiny-random-mbart''', {})
								for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
														with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})"   ):
																				lowerCAmelCase_      			=  self.rust_tokenizer_class.from_pretrained(UpperCamelCase__,	**UpperCamelCase__   )
																				lowerCAmelCase_      			=  self.tokenizer_class.from_pretrained(UpperCamelCase__,	**UpperCamelCase__   )

																				lowerCAmelCase_      			=  tempfile.mkdtemp()

																				lowerCAmelCase_      			=  tokenizer_r.save_pretrained(UpperCamelCase__   )
																				lowerCAmelCase_      			=  tokenizer_p.save_pretrained(UpperCamelCase__   )

																				# Checks it save with the same files + the tokenizer.json file for the fast one
																				self.assertTrue(any('''tokenizer.json''' in f for f in tokenizer_r_files   )   )
																				lowerCAmelCase_      			=  tuple(f for f in tokenizer_r_files if '''tokenizer.json''' not in f   )
																				self.assertSequenceEqual(UpperCamelCase__,	UpperCamelCase__   )

																				# Checks everything loads correctly in the same way
																				lowerCAmelCase_      			=  tokenizer_r.from_pretrained(UpperCamelCase__   )
																				lowerCAmelCase_      			=  tokenizer_p.from_pretrained(UpperCamelCase__   )

																				# Check special tokens are set accordingly on Rust and Python
																				for key in tokenizer_pp.special_tokens_map:
																										self.assertTrue(hasattr(UpperCamelCase__,	UpperCamelCase__   )   )
																										# self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key))
																										# self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id"))

																				shutil.rmtree(UpperCamelCase__   )

																				# Save tokenizer rust, legacy_format=True
																				lowerCAmelCase_      			=  tempfile.mkdtemp()

																				lowerCAmelCase_      			=  tokenizer_r.save_pretrained(UpperCamelCase__,	legacy_format=UpperCamelCase__   )
																				lowerCAmelCase_      			=  tokenizer_p.save_pretrained(UpperCamelCase__   )

																				# Checks it save with the same files
																				self.assertSequenceEqual(UpperCamelCase__,	UpperCamelCase__   )

																				# Checks everything loads correctly in the same way
																				lowerCAmelCase_      			=  tokenizer_r.from_pretrained(UpperCamelCase__   )
																				lowerCAmelCase_      			=  tokenizer_p.from_pretrained(UpperCamelCase__   )

																				# Check special tokens are set accordingly on Rust and Python
																				for key in tokenizer_pp.special_tokens_map:
																										self.assertTrue(hasattr(UpperCamelCase__,	UpperCamelCase__   )   )

																				shutil.rmtree(UpperCamelCase__   )

																				# Save tokenizer rust, legacy_format=False
																				lowerCAmelCase_      			=  tempfile.mkdtemp()

																				lowerCAmelCase_      			=  tokenizer_r.save_pretrained(UpperCamelCase__,	legacy_format=UpperCamelCase__   )
																				lowerCAmelCase_      			=  tokenizer_p.save_pretrained(UpperCamelCase__   )

																				# Checks it saved the tokenizer.json file
																				self.assertTrue(any('''tokenizer.json''' in f for f in tokenizer_r_files   )   )

																				# Checks everything loads correctly in the same way
																				lowerCAmelCase_      			=  tokenizer_r.from_pretrained(UpperCamelCase__   )
																				lowerCAmelCase_      			=  tokenizer_p.from_pretrained(UpperCamelCase__   )

																				# Check special tokens are set accordingly on Rust and Python
																				for key in tokenizer_pp.special_tokens_map:
																										self.assertTrue(hasattr(UpperCamelCase__,	UpperCamelCase__   )   )

																				shutil.rmtree(UpperCamelCase__   )







@require_torch
@require_sentencepiece
@require_tokenizers
class  A		(  unittest.TestCase     ):
		__snake_case									=   'facebook/mbart-large-en-ro'
		__snake_case									=   [
		    ' UN Chief Says There Is No Military Solution in Syria',
		    ' Secretary-General Ban Ki-moon says his response to Russia\'s stepped up military support for Syria is that "there is no military solution" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.',
		]
		__snake_case									=   [
		    'Şeful ONU declară că nu există o soluţie militară în Siria',
		    'Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei'
		    ' pentru Siria este că "nu există o soluţie militară" la conflictul de aproape cinci ani şi că noi arme nu vor'
		    ' face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.',
		]
		__snake_case									=   [8274, 12_7873, 2_5916, 7, 8622, 2071, 438, 6_7485, 53, 18_7895, 23, 5_1712, 2, EN_CODE]



		@classmethod
		def        SCREAMING_SNAKE_CASE__			(     cls   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  MBartTokenizer.from_pretrained(
								    cls.checkpoint_name,	src_lang='''en_XX''',	tgt_lang='''ro_RO'''   )
								lowerCAmelCase_      			=  1
								return cls



		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ar_AR'''],	25_0001   )
								self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''en_EN'''],	25_0004   )
								self.assertEqual(self.tokenizer.fairseq_tokens_to_ids['''ro_RO'''],	25_0020   )



		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  self.tokenizer.batch_encode_plus(self.src_text   ).input_ids[0]
								self.assertListEqual(self.expected_src_tokens,	UpperCamelCase__   )



		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								self.assertIn(UpperCamelCase__,	self.tokenizer.all_special_ids   )
								lowerCAmelCase_      			=  [RO_CODE, 884, 9019, 96, 9, 916, 8_6792, 36, 1_8743, 1_5596, 5, 2]
								lowerCAmelCase_      			=  self.tokenizer.decode(UpperCamelCase__,	skip_special_tokens=UpperCamelCase__   )
								lowerCAmelCase_      			=  self.tokenizer.decode(generated_ids[1:],	skip_special_tokens=UpperCamelCase__   )
								self.assertEqual(UpperCamelCase__,	UpperCamelCase__   )
								self.assertNotIn(self.tokenizer.eos_token,	UpperCamelCase__   )



		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  ['''this is gunna be a long sentence ''' * 20]
								assert isinstance(src_text[0],	UpperCamelCase__   )
								lowerCAmelCase_      			=  10
								lowerCAmelCase_      			=  self.tokenizer(UpperCamelCase__,	max_length=UpperCamelCase__,	truncation=UpperCamelCase__   ).input_ids[0]
								self.assertEqual(ids[-2],	2   )
								self.assertEqual(ids[-1],	UpperCamelCase__   )
								self.assertEqual(len(UpperCamelCase__   ),	UpperCamelCase__   )



		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								self.assertListEqual(self.tokenizer.convert_tokens_to_ids(['''<mask>''', '''ar_AR''']   ),	[25_0026, 25_0001]   )



		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  tempfile.mkdtemp()
								lowerCAmelCase_      			=  self.tokenizer.fairseq_tokens_to_ids
								self.tokenizer.save_pretrained(UpperCamelCase__   )
								lowerCAmelCase_      			=  MBartTokenizer.from_pretrained(UpperCamelCase__   )
								self.assertDictEqual(new_tok.fairseq_tokens_to_ids,	UpperCamelCase__   )



		@require_torch
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  self.tokenizer(self.src_text,	text_target=self.tgt_text,	padding=UpperCamelCase__,	return_tensors='''pt'''   )
								lowerCAmelCase_      			=  shift_tokens_right(batch['''labels'''],	self.tokenizer.pad_token_id   )

								# fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
								assert batch.input_ids[1][-2:].tolist() == [2, EN_CODE]
								assert batch.decoder_input_ids[1][0].tolist() == RO_CODE
								assert batch.decoder_input_ids[1][-1] == 2
								assert batch.labels[1][-2:].tolist() == [2, RO_CODE]



		@require_torch
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  self.tokenizer(
								    self.src_text,	text_target=self.tgt_text,	padding=UpperCamelCase__,	truncation=UpperCamelCase__,	max_length=len(self.expected_src_tokens   ),	return_tensors='''pt''',	)

								lowerCAmelCase_      			=  shift_tokens_right(batch['''labels'''],	self.tokenizer.pad_token_id   )

								self.assertIsInstance(UpperCamelCase__,	UpperCamelCase__   )

								self.assertEqual((2, 14),	batch.input_ids.shape   )
								self.assertEqual((2, 14),	batch.attention_mask.shape   )
								lowerCAmelCase_      			=  batch.input_ids.tolist()[0]
								self.assertListEqual(self.expected_src_tokens,	UpperCamelCase__   )
								self.assertEqual(2,	batch.decoder_input_ids[0, -1]   )  # EOS
								# Test that special tokens are reset
								self.assertEqual(self.tokenizer.prefix_tokens,	[]   )
								self.assertEqual(self.tokenizer.suffix_tokens,	[self.tokenizer.eos_token_id, EN_CODE]   )



		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  self.tokenizer(self.src_text,	padding=UpperCamelCase__,	truncation=UpperCamelCase__,	max_length=3,	return_tensors='''pt'''   )
								lowerCAmelCase_      			=  self.tokenizer(
								    text_target=self.tgt_text,	padding=UpperCamelCase__,	truncation=UpperCamelCase__,	max_length=10,	return_tensors='''pt'''   )
								lowerCAmelCase_      			=  targets['''input_ids''']
								lowerCAmelCase_      			=  shift_tokens_right(UpperCamelCase__,	self.tokenizer.pad_token_id   )

								self.assertEqual(batch.input_ids.shape[1],	3   )
								self.assertEqual(batch.decoder_input_ids.shape[1],	10   )







		@require_torch
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  self.tokenizer._build_translation_inputs(
								    '''A test''',	return_tensors='''pt''',	src_lang='''en_XX''',	tgt_lang='''ar_AR'''   )

								self.assertEqual(
								    nested_simplify(UpperCamelCase__   ),	{
								        # A, test, EOS, en_XX
								        '''input_ids''': [[62, 3034, 2, 25_0004]],
								        '''attention_mask''': [[1, 1, 1, 1]],
								        # ar_AR
								        '''forced_bos_token_id''': 25_0001,
								    },	)










import argparse
import json

import requests
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from torchvision import transforms

from transformers import BitImageProcessor, FocalNetConfig, FocalNetForImageClassification
from transformers.image_utils import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD, PILImageResampling





def __UpperCamelCase			(       _A  ):
						lowerCAmelCase_      			=  [2, 2, 6, 2] if '''tiny''' in model_name else [2, 2, 18, 2]
						lowerCAmelCase_      			=  True if '''large''' in model_name or '''huge''' in model_name else False
						lowerCAmelCase_      			=  True if '''large''' in model_name or '''huge''' in model_name else False
						lowerCAmelCase_      			=  True if '''large''' in model_name or '''huge''' in model_name else False

						if "large" in model_name or "xlarge" in model_name or "huge" in model_name:
												if "fl3" in model_name:
																		lowerCAmelCase_      			=  [3, 3, 3, 3]
																		lowerCAmelCase_      			=  [5, 5, 5, 5]
												elif "fl4" in model_name:
																		lowerCAmelCase_      			=  [4, 4, 4, 4]
																		lowerCAmelCase_      			=  [3, 3, 3, 3]

						if "tiny" in model_name or "small" in model_name or "base" in model_name:
												lowerCAmelCase_      			=  [3, 3, 3, 3]
												if "lrf" in model_name:
																		lowerCAmelCase_      			=  [3, 3, 3, 3]
												else:
																		lowerCAmelCase_      			=  [2, 2, 2, 2]

						if "tiny" in model_name:
												lowerCAmelCase_      			=  96
						elif "small" in model_name:
												lowerCAmelCase_      			=  96
						elif "base" in model_name:
												lowerCAmelCase_      			=  128
						elif "large" in model_name:
												lowerCAmelCase_      			=  192
						elif "xlarge" in model_name:
												lowerCAmelCase_      			=  256
						elif "huge" in model_name:
												lowerCAmelCase_      			=  352

						# set label information
						lowerCAmelCase_      			=  '''huggingface/label-files'''
						if "large" in model_name or "huge" in model_name:
												lowerCAmelCase_      			=  '''imagenet-22k-id2label.json'''
						else:
												lowerCAmelCase_      			=  '''imagenet-1k-id2label.json'''

						lowerCAmelCase_      			=  json.load(open(hf_hub_download(_A ,  _A ,  repo_type='''dataset'''  ) ,  '''r'''  )  )
						lowerCAmelCase_      			=  {int(_A  ): v for k, v in idalabel.items()}
						lowerCAmelCase_      			=  {v: k for k, v in idalabel.items()}

						lowerCAmelCase_      			=  FocalNetConfig(
						    embed_dim=_A ,  depths=_A ,  focal_levels=_A ,  focal_windows=_A ,  use_conv_embed=_A ,  idalabel=_A ,  labelaid=_A ,  use_post_layernorm=_A ,  use_layerscale=_A ,  )

						return config





def __UpperCamelCase			(       _A  ):
						if "patch_embed.proj" in name:
												lowerCAmelCase_      			=  name.replace('''patch_embed.proj''' ,  '''embeddings.patch_embeddings.projection'''  )
						if "patch_embed.norm" in name:
												lowerCAmelCase_      			=  name.replace('''patch_embed.norm''' ,  '''embeddings.norm'''  )
						if "layers" in name:
												lowerCAmelCase_      			=  '''encoder.''' + name
						if "encoder.layers" in name:
												lowerCAmelCase_      			=  name.replace('''encoder.layers''' ,  '''encoder.stages'''  )
						if "downsample.proj" in name:
												lowerCAmelCase_      			=  name.replace('''downsample.proj''' ,  '''downsample.projection'''  )
						if "blocks" in name:
												lowerCAmelCase_      			=  name.replace('''blocks''' ,  '''layers'''  )
						if "modulation.f.weight" in name or "modulation.f.bias" in name:
												lowerCAmelCase_      			=  name.replace('''modulation.f''' ,  '''modulation.projection_in'''  )
						if "modulation.h.weight" in name or "modulation.h.bias" in name:
												lowerCAmelCase_      			=  name.replace('''modulation.h''' ,  '''modulation.projection_context'''  )
						if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
												lowerCAmelCase_      			=  name.replace('''modulation.proj''' ,  '''modulation.projection_out'''  )

						if name == "norm.weight":
												lowerCAmelCase_      			=  '''layernorm.weight'''
						if name == "norm.bias":
												lowerCAmelCase_      			=  '''layernorm.bias'''

						if "head" in name:
												lowerCAmelCase_      			=  name.replace('''head''' ,  '''classifier'''  )
						else:
												lowerCAmelCase_      			=  '''focalnet.''' + name

						return name





def __UpperCamelCase			(       _A ,  _A ,  _A=False  ):
						# fmt: off
						lowerCAmelCase_      			=  {
						    '''focalnet-tiny''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_srf.pth''',
						    '''focalnet-tiny-lrf''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_tiny_lrf.pth''',
						    '''focalnet-small''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_srf.pth''',
						    '''focalnet-small-lrf''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_small_lrf.pth''',
						    '''focalnet-base''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_srf.pth''',
						    '''focalnet-base-lrf''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_base_lrf.pth''',
						    '''focalnet-large-lrf-fl3''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384.pth''',
						    '''focalnet-large-lrf-fl4''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_large_lrf_384_fl4.pth''',
						    '''focalnet-xlarge-lrf-fl3''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384.pth''',
						    '''focalnet-xlarge-lrf-fl4''': '''https://projects4jw.blob.core.windows.net/focalnet/release/classification/focalnet_xlarge_lrf_384_fl4.pth''',
						}
						# fmt: on

						lowerCAmelCase_      			=  model_name_to_url[model_name]
						print('''Checkpoint URL: ''' ,  _A  )
						lowerCAmelCase_      			=  torch.hub.load_state_dict_from_url(_A ,  map_location='''cpu'''  )['''model''']

						# rename keys
						for key in state_dict.copy().keys():
												lowerCAmelCase_      			=  state_dict.pop(_A  )
												lowerCAmelCase_      			=  val

						lowerCAmelCase_      			=  get_focalnet_config(_A  )
						lowerCAmelCase_      			=  FocalNetForImageClassification(_A  )
						model.eval()

						# load state dict
						model.load_state_dict(_A  )

						# verify conversion
						lowerCAmelCase_      			=  '''http://images.cocodataset.org/val2017/000000039769.jpg'''

						lowerCAmelCase_      			=  BitImageProcessor(
						    do_resize=_A ,  size={'''shortest_edge''': 256} ,  resample=PILImageResampling.BILINEAR ,  do_center_crop=_A ,  crop_size=224 ,  do_normalize=_A ,  image_mean=_A ,  image_std=_A ,  )
						lowerCAmelCase_      			=  Image.open(requests.get(_A ,  stream=_A  ).raw  )
						lowerCAmelCase_      			=  processor(images=_A ,  return_tensors='''pt'''  )

						lowerCAmelCase_      			=  transforms.Compose(
						    [
						        transforms.Resize(256  ),
						        transforms.CenterCrop(224  ),
						        transforms.ToTensor(),
						        transforms.Normalize(mean=[0.4_8_5, 0.4_5_6, 0.4_0_6] ,  std=[0.2_2_9, 0.2_2_4, 0.2_2_5]  ),
						    ]  )

						lowerCAmelCase_      			=  image_transforms(_A  ).unsqueeze(0  )

						# verify pixel_values
						assert torch.allclose(inputs.pixel_values ,  _A ,  atol=1E-4  )

						lowerCAmelCase_      			=  model(**_A  )

						lowerCAmelCase_      			=  outputs.logits.argmax(-1  ).item()
						print('''Predicted class:''' ,  model.config.idalabel[predicted_class_idx]  )

						print('''First values of logits:''' ,  outputs.logits[0, :3]  )

						if model_name == "focalnet-tiny":
												lowerCAmelCase_      			=  torch.tensor([0.2_1_6_6, -0.4_3_6_8, 0.2_1_9_1]  )
						elif model_name == "focalnet-tiny-lrf":
												lowerCAmelCase_      			=  torch.tensor([1.1_6_6_9, 0.0_1_2_5, -0.1_6_9_5]  )
						elif model_name == "focalnet-small":
												lowerCAmelCase_      			=  torch.tensor([0.4_9_1_7, -0.0_4_3_0, 0.1_3_4_1]  )
						elif model_name == "focalnet-small-lrf":
												lowerCAmelCase_      			=  torch.tensor([-0.2_5_8_8, -0.5_3_4_2, -0.2_3_3_1]  )
						elif model_name == "focalnet-base":
												lowerCAmelCase_      			=  torch.tensor([-0.1_6_5_5, -0.4_0_9_0, -0.1_7_3_0]  )
						elif model_name == "focalnet-base-lrf":
												lowerCAmelCase_      			=  torch.tensor([0.5_3_0_6, -0.0_4_8_3, -0.3_9_2_8]  )
						assert torch.allclose(outputs.logits[0, :3] ,  _A ,  atol=1E-4  )
						print('''Looks ok!'''  )

						if pytorch_dump_folder_path is not None:
												print(f"Saving model and processor of {model_name} to {pytorch_dump_folder_path}"  )
												model.save_pretrained(_A  )
												processor.save_pretrained(_A  )

						if push_to_hub:
												print(f"Pushing model and processor of {model_name} to the hub..."  )
												model.push_to_hub(f"{model_name}"  )
												processor.push_to_hub(f"{model_name}"  )


if __name__ == "__main__":
						_A     =			argparse.ArgumentParser()
						# Required parameters
						parser.add_argument(
						    '''--model_name''',
						    default='''focalnet-tiny''',
						    type=str,
						    help='''Name of the FocalNet model you\'d like to convert.''',
						)
						parser.add_argument(
						    '''--pytorch_dump_folder_path''', default=None, type=str, help='''Path to the output PyTorch model directory.'''
						)
						parser.add_argument(
						    '''--push_to_hub''',
						    action='''store_true''',
						    help='''Whether to push the model and processor to the hub.''',
						)

						_A     =			parser.parse_args()
						convert_focalnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)




