
"""simple docstring"""




import itertools
import random
import unittest

import numpy as np

from transformers import is_speech_available
from transformers.testing_utils import require_torch, require_torchaudio

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
						from transformers import SpeechaTextFeatureExtractor

lowerCAmelCase__							=				random.Random()



def        _lowerCamelCase ( __a,							__a=1.0,							__a=None,							__a=None    ):
		if rng is None:
				SCREAMING_SNAKE_CASE_						 = global_rng

		SCREAMING_SNAKE_CASE_						 = []
		for batch_idx in range(shape[0]    ):
				values.append([]    )
				for _ in range(shape[1]    ):
						values[-1].append(rng.random() * scale    )

		return values





@require_torch
@require_torchaudio
class  snake_case     (							unittest.TestCase   ):

							def __init__(self       ,       SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_=7       ,       SCREAMING_SNAKE_CASE_=4_00       ,       SCREAMING_SNAKE_CASE_=20_00       ,       SCREAMING_SNAKE_CASE_=24       ,       SCREAMING_SNAKE_CASE_=24       ,       SCREAMING_SNAKE_CASE_=0.0       ,       SCREAMING_SNAKE_CASE_=1_60_00       ,       SCREAMING_SNAKE_CASE_=True       ,       SCREAMING_SNAKE_CASE_=True       ,       ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = parent
									SCREAMING_SNAKE_CASE_						 = batch_size
									SCREAMING_SNAKE_CASE_						 = min_seq_length
									SCREAMING_SNAKE_CASE_						 = max_seq_length
									SCREAMING_SNAKE_CASE_						 = (self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
									SCREAMING_SNAKE_CASE_						 = feature_size
									SCREAMING_SNAKE_CASE_						 = num_mel_bins
									SCREAMING_SNAKE_CASE_						 = padding_value
									SCREAMING_SNAKE_CASE_						 = sampling_rate
									SCREAMING_SNAKE_CASE_						 = return_attention_mask
									SCREAMING_SNAKE_CASE_						 = do_normalize

							def _lowercase					(self    ):

									"""simple docstring"""







									return {
									    "feature_size": self.feature_size,
									    "num_mel_bins": self.num_mel_bins,
									    "padding_value": self.padding_value,
									    "sampling_rate": self.sampling_rate,
									    "return_attention_mask": self.return_attention_mask,
									    "do_normalize": self.do_normalize,
									}







							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_=False       ,       SCREAMING_SNAKE_CASE_=False    ):

									"""simple docstring"""







									def _flatten(SCREAMING_SNAKE_CASE_    ):
											return list(itertools.chain(*SCREAMING_SNAKE_CASE_    )    )

									if equal_length:
											SCREAMING_SNAKE_CASE_						 = [floats_list((self.max_seq_length, self.feature_size)    ) for _ in range(self.batch_size    )]
									else:
											# make sure that inputs increase in size
											SCREAMING_SNAKE_CASE_						 = [
											    floats_list((x, self.feature_size)    )
											    for x in range(self.min_seq_length       ,       self.max_seq_length       ,       self.seq_length_diff    )
											]
									if numpify:
											SCREAMING_SNAKE_CASE_						 = [np.asarray(SCREAMING_SNAKE_CASE_    ) for x in speech_inputs]
									return speech_inputs







@require_torch
@require_torchaudio
class  snake_case     (							__lowercase       ,			unittest.TestCase   ):
							UpperCAmelCase__						     =      SpeechaTextFeatureExtractor if is_speech_available() else None

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = SpeechaTextFeatureExtractionTester(self    )

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									self.assertTrue(np.all(np.mean(SCREAMING_SNAKE_CASE_       ,       axis=0    ) < 1e-3    )    )
									self.assertTrue(np.all(np.abs(np.var(SCREAMING_SNAKE_CASE_       ,       axis=0    ) - 1    ) < 1e-3    )    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
									# create three inputs of length 800, 1000, and 1200
									SCREAMING_SNAKE_CASE_						 = [floats_list((1, x)    )[0] for x in range(8_00       ,       14_00       ,       2_00    )]
									SCREAMING_SNAKE_CASE_						 = [np.asarray(SCREAMING_SNAKE_CASE_    ) for speech_input in speech_inputs]

									# Test feature size
									SCREAMING_SNAKE_CASE_						 = feature_extractor(SCREAMING_SNAKE_CASE_       ,       padding=SCREAMING_SNAKE_CASE_       ,       return_tensors='''np'''    ).input_features
									self.assertTrue(input_features.ndim == 3    )
									self.assertTrue(input_features.shape[-1] == feature_extractor.feature_size    )

									# Test not batched input
									SCREAMING_SNAKE_CASE_						 = feature_extractor(speech_inputs[0]       ,       return_tensors='''np'''    ).input_features
									SCREAMING_SNAKE_CASE_						 = feature_extractor(np_speech_inputs[0]       ,       return_tensors='''np'''    ).input_features
									self.assertTrue(np.allclose(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       atol=1e-3    )    )

									# Test batched
									SCREAMING_SNAKE_CASE_						 = feature_extractor(SCREAMING_SNAKE_CASE_       ,       return_tensors='''np'''    ).input_features
									SCREAMING_SNAKE_CASE_						 = feature_extractor(SCREAMING_SNAKE_CASE_       ,       return_tensors='''np'''    ).input_features
									for enc_seq_a, enc_seq_a in zip(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    ):
											self.assertTrue(np.allclose(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       atol=1e-3    )    )

									# Test 2-D numpy arrays are batched.
									SCREAMING_SNAKE_CASE_						 = [floats_list((1, x)    )[0] for x in (8_00, 8_00, 8_00)]
									SCREAMING_SNAKE_CASE_						 = np.asarray(SCREAMING_SNAKE_CASE_    )
									SCREAMING_SNAKE_CASE_						 = feature_extractor(SCREAMING_SNAKE_CASE_       ,       return_tensors='''np'''    ).input_features
									SCREAMING_SNAKE_CASE_						 = feature_extractor(SCREAMING_SNAKE_CASE_       ,       return_tensors='''np'''    ).input_features
									for enc_seq_a, enc_seq_a in zip(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    ):
											self.assertTrue(np.allclose(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_       ,       atol=1e-3    )    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
									SCREAMING_SNAKE_CASE_						 = [floats_list((1, x)    )[0] for x in range(8_00       ,       14_00       ,       2_00    )]

									SCREAMING_SNAKE_CASE_						 = ['''longest''', '''max_length''', '''do_not_pad''']
									SCREAMING_SNAKE_CASE_						 = [None, 16, None]
									for max_length, padding in zip(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    ):
											SCREAMING_SNAKE_CASE_						 = feature_extractor(
											    SCREAMING_SNAKE_CASE_       ,       padding=SCREAMING_SNAKE_CASE_       ,       max_length=SCREAMING_SNAKE_CASE_       ,       return_attention_mask=SCREAMING_SNAKE_CASE_    )
											SCREAMING_SNAKE_CASE_						 = inputs.input_features
											SCREAMING_SNAKE_CASE_						 = inputs.attention_mask
											SCREAMING_SNAKE_CASE_						 = [np.sum(SCREAMING_SNAKE_CASE_    ) for x in attention_mask]

											self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]    )
											self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]    )
											self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
									SCREAMING_SNAKE_CASE_						 = [floats_list((1, x)    )[0] for x in range(8_00       ,       14_00       ,       2_00    )]

									SCREAMING_SNAKE_CASE_						 = ['''longest''', '''max_length''', '''do_not_pad''']
									SCREAMING_SNAKE_CASE_						 = [None, 16, None]
									for max_length, padding in zip(SCREAMING_SNAKE_CASE_       ,       SCREAMING_SNAKE_CASE_    ):
											SCREAMING_SNAKE_CASE_						 = feature_extractor(
											    SCREAMING_SNAKE_CASE_       ,       max_length=SCREAMING_SNAKE_CASE_       ,       padding=SCREAMING_SNAKE_CASE_       ,       return_tensors='''np'''       ,       return_attention_mask=SCREAMING_SNAKE_CASE_    )
											SCREAMING_SNAKE_CASE_						 = inputs.input_features
											SCREAMING_SNAKE_CASE_						 = inputs.attention_mask
											SCREAMING_SNAKE_CASE_						 = [np.sum(SCREAMING_SNAKE_CASE_    ) for x in attention_mask]

											self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]    )
											self.assertTrue(input_features[0][fbank_feat_lengths[0] :].sum() < 1e-6    )
											self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]    )
											self.assertTrue(input_features[0][fbank_feat_lengths[1] :].sum() < 1e-6    )
											self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
									SCREAMING_SNAKE_CASE_						 = [floats_list((1, x)    )[0] for x in range(8_00       ,       14_00       ,       2_00    )]
									SCREAMING_SNAKE_CASE_						 = feature_extractor(
									    SCREAMING_SNAKE_CASE_       ,       padding='''max_length'''       ,       max_length=4       ,       truncation=SCREAMING_SNAKE_CASE_       ,       return_tensors='''np'''       ,       return_attention_mask=SCREAMING_SNAKE_CASE_       ,       )
									SCREAMING_SNAKE_CASE_						 = inputs.input_features
									SCREAMING_SNAKE_CASE_						 = inputs.attention_mask
									SCREAMING_SNAKE_CASE_						 = np.sum(attention_mask == 1       ,       axis=1    )

									self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]    )
									self._check_zero_mean_unit_variance(input_features[1]    )
									self._check_zero_mean_unit_variance(input_features[2]    )

							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
									SCREAMING_SNAKE_CASE_						 = [floats_list((1, x)    )[0] for x in range(8_00       ,       14_00       ,       2_00    )]
									SCREAMING_SNAKE_CASE_						 = feature_extractor(
									    SCREAMING_SNAKE_CASE_       ,       padding='''longest'''       ,       max_length=4       ,       truncation=SCREAMING_SNAKE_CASE_       ,       return_tensors='''np'''       ,       return_attention_mask=SCREAMING_SNAKE_CASE_       ,       )
									SCREAMING_SNAKE_CASE_						 = inputs.input_features
									SCREAMING_SNAKE_CASE_						 = inputs.attention_mask
									SCREAMING_SNAKE_CASE_						 = np.sum(attention_mask == 1       ,       axis=1    )

									self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]    )
									self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]    )
									self._check_zero_mean_unit_variance(input_features[2]    )

									# make sure that if max_length < longest -> then pad to max_length
									self.assertEqual(input_features.shape       ,       (3, 4, 24)    )

									SCREAMING_SNAKE_CASE_						 = [floats_list((1, x)    )[0] for x in range(8_00       ,       14_00       ,       2_00    )]
									SCREAMING_SNAKE_CASE_						 = feature_extractor(
									    SCREAMING_SNAKE_CASE_       ,       padding='''longest'''       ,       max_length=16       ,       truncation=SCREAMING_SNAKE_CASE_       ,       return_tensors='''np'''       ,       return_attention_mask=SCREAMING_SNAKE_CASE_       ,       )
									SCREAMING_SNAKE_CASE_						 = inputs.input_features
									SCREAMING_SNAKE_CASE_						 = inputs.attention_mask
									SCREAMING_SNAKE_CASE_						 = np.sum(attention_mask == 1       ,       axis=1    )

									self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]    )
									self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]    )
									self._check_zero_mean_unit_variance(input_features[2]    )

									# make sure that if max_length < longest -> then pad to max_length
									self.assertEqual(input_features.shape       ,       (3, 6, 24)    )

							def _lowercase					(self    ):

									"""simple docstring"""







									import torch

									SCREAMING_SNAKE_CASE_						 = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
									SCREAMING_SNAKE_CASE_						 = np.random.rand(1_00       ,       32    ).astype(np.floataa    )
									SCREAMING_SNAKE_CASE_						 = np_speech_inputs.tolist()

									for inputs in [py_speech_inputs, np_speech_inputs]:
											SCREAMING_SNAKE_CASE_						 = feature_extractor.pad([{'''input_features''': inputs}]       ,       return_tensors='''np'''    )
											self.assertTrue(np_processed.input_features.dtype == np.floataa    )
											SCREAMING_SNAKE_CASE_						 = feature_extractor.pad([{'''input_features''': inputs}]       ,       return_tensors='''pt'''    )
											self.assertTrue(pt_processed.input_features.dtype == torch.floataa    )

							def _lowercase					(self       ,       SCREAMING_SNAKE_CASE_    ):

									"""simple docstring"""







									from datasets import load_dataset

									SCREAMING_SNAKE_CASE_						 = load_dataset('''hf-internal-testing/librispeech_asr_dummy'''       ,       '''clean'''       ,       split='''validation'''    )
									# automatic decoding with librispeech
									SCREAMING_SNAKE_CASE_						 = ds.sort('''id'''    ).select(range(SCREAMING_SNAKE_CASE_    )    )[:num_samples]['''audio''']

									return [x["array"] for x in speech_samples]







							def _lowercase					(self    ):

									"""simple docstring"""







									SCREAMING_SNAKE_CASE_						 = np.array([
									    -1.57_45, -1.77_13, -1.70_20, -1.60_69, -1.22_50, -1.11_05, -0.90_72, -0.82_41,
									    -1.23_10, -0.80_98, -0.33_20, -0.41_01, -0.79_85, -0.49_96, -0.82_13, -0.91_28,
									    -1.04_20, -1.12_86, -1.04_40, -0.79_99, -0.84_05, -1.22_75, -1.54_43, -1.46_25,
									]    )
									# fmt: on

									SCREAMING_SNAKE_CASE_						 = self._load_datasamples(1    )
									SCREAMING_SNAKE_CASE_						 = self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()    )
									SCREAMING_SNAKE_CASE_						 = feature_extractor(SCREAMING_SNAKE_CASE_       ,       return_tensors='''pt'''    ).input_features
									self.assertEquals(input_features.shape       ,       (1, 5_84, 24)    )
									self.assertTrue(np.allclose(input_features[0, 0, :30]       ,       SCREAMING_SNAKE_CASE_       ,       atol=1e-4    )    )

"""simple docstring"""




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        _lowerCamelCase ( __a    ):
		SCREAMING_SNAKE_CASE_						 = [2, 2, 6, 2] if '''tiny''' in model_name else [2, 2, 18, 2]
		SCREAMING_SNAKE_CASE_						 = True if '''large''' in model_name or '''huge''' in model_name else False
		SCREAMING_SNAKE_CASE_						 = True if '''large''' in model_name or '''huge''' in model_name else False
		SCREAMING_SNAKE_CASE_						 = 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:
						SCREAMING_SNAKE_CASE_						 = [3, 3, 3, 3]
						SCREAMING_SNAKE_CASE_						 = [5, 5, 5, 5]
				elif "fl4" in model_name:
						SCREAMING_SNAKE_CASE_						 = [4, 4, 4, 4]
						SCREAMING_SNAKE_CASE_						 = [3, 3, 3, 3]

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

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

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

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

		SCREAMING_SNAKE_CASE_						 = 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        _lowerCamelCase ( __a    ):
		if "patch_embed.proj" in name:
				SCREAMING_SNAKE_CASE_						 = name.replace('''patch_embed.proj''',							'''embeddings.patch_embeddings.projection'''    )
		if "patch_embed.norm" in name:
				SCREAMING_SNAKE_CASE_						 = name.replace('''patch_embed.norm''',							'''embeddings.norm'''    )
		if "layers" in name:
				SCREAMING_SNAKE_CASE_						 = '''encoder.''' + name
		if "encoder.layers" in name:
				SCREAMING_SNAKE_CASE_						 = name.replace('''encoder.layers''',							'''encoder.stages'''    )
		if "downsample.proj" in name:
				SCREAMING_SNAKE_CASE_						 = name.replace('''downsample.proj''',							'''downsample.projection'''    )
		if "blocks" in name:
				SCREAMING_SNAKE_CASE_						 = name.replace('''blocks''',							'''layers'''    )
		if "modulation.f.weight" in name or "modulation.f.bias" in name:
				SCREAMING_SNAKE_CASE_						 = name.replace('''modulation.f''',							'''modulation.projection_in'''    )
		if "modulation.h.weight" in name or "modulation.h.bias" in name:
				SCREAMING_SNAKE_CASE_						 = name.replace('''modulation.h''',							'''modulation.projection_context'''    )
		if "modulation.proj.weight" in name or "modulation.proj.bias" in name:
				SCREAMING_SNAKE_CASE_						 = name.replace('''modulation.proj''',							'''modulation.projection_out'''    )

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

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

		return name



def        _lowerCamelCase ( __a,							__a,							__a=False    ):
		# fmt: off
		SCREAMING_SNAKE_CASE_						 = {
		    '''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

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

		# rename keys
		for key in state_dict.copy().keys():
				SCREAMING_SNAKE_CASE_						 = state_dict.pop(__a    )
				SCREAMING_SNAKE_CASE_						 = val

		SCREAMING_SNAKE_CASE_						 = get_focalnet_config(__a    )
		SCREAMING_SNAKE_CASE_						 = FocalNetForImageClassification(__a    )
		model.eval()

		# load state dict
		model.load_state_dict(__a    )

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

		SCREAMING_SNAKE_CASE_						 = 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,							)
		SCREAMING_SNAKE_CASE_						 = Image.open(requests.get(__a,							stream=__a    ).raw    )
		SCREAMING_SNAKE_CASE_						 = processor(images=__a,							return_tensors='''pt'''    )

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

		SCREAMING_SNAKE_CASE_						 = image_transforms(__a    ).unsqueeze(0    )

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

		SCREAMING_SNAKE_CASE_						 = model(**__a    )

		SCREAMING_SNAKE_CASE_						 = 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":
				SCREAMING_SNAKE_CASE_						 = torch.tensor([0.2_1_6_6, -0.4_3_6_8, 0.2_1_9_1]    )
		elif model_name == "focalnet-tiny-lrf":
				SCREAMING_SNAKE_CASE_						 = torch.tensor([1.1_6_6_9, 0.0_1_2_5, -0.1_6_9_5]    )
		elif model_name == "focalnet-small":
				SCREAMING_SNAKE_CASE_						 = torch.tensor([0.4_9_1_7, -0.0_4_3_0, 0.1_3_4_1]    )
		elif model_name == "focalnet-small-lrf":
				SCREAMING_SNAKE_CASE_						 = torch.tensor([-0.2_5_8_8, -0.5_3_4_2, -0.2_3_3_1]    )
		elif model_name == "focalnet-base":
				SCREAMING_SNAKE_CASE_						 = torch.tensor([-0.1_6_5_5, -0.4_0_9_0, -0.1_7_3_0]    )
		elif model_name == "focalnet-base-lrf":
				SCREAMING_SNAKE_CASE_						 = 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__":
						lowerCAmelCase__							=				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.',
						)

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