





import copy
import fnmatch
import json
import os
import pickle as pkl
import shutil
import sys
import tarfile
import tempfile
from collections import OrderedDict
from contextlib import contextmanager
from functools import partial
from hashlib import shaaaa
from io import BytesIO
from pathlib import Path
from urllib.parse import urlparse
from zipfile import ZipFile, is_zipfile

import cva
import numpy as np
import requests
import wget
from filelock import FileLock
from PIL import Image
from tqdm.auto import tqdm
from yaml import Loader, dump, load


try:
							import torch

							UpperCAmelCase__						:			int									=True
except ImportError:
							UpperCAmelCase__						:			Dict									=False


try:
							from torch.hub import _get_torch_home

							UpperCAmelCase__						:			int									=_get_torch_home()
except ImportError:
							UpperCAmelCase__						:			str									=os.path.expanduser(
							    os.getenv('''TORCH_HOME''', os.path.join(os.getenv('''XDG_CACHE_HOME''', '''~/.cache'''), '''torch'''))
							)

UpperCAmelCase__						:			Optional[Any]									=os.path.join(torch_cache_home, '''transformers''')

UpperCAmelCase__						:			List[Any]									='''https://cdn.huggingface.co'''
UpperCAmelCase__						:			List[Any]									='''https://s3.amazonaws.com/models.huggingface.co/bert'''
UpperCAmelCase__						:			Dict									='''/'''.join(str(Path(__file__).resolve()).split('''/''')[:-1])
UpperCAmelCase__						:			Union[str, Any]									=os.path.join(PATH, '''config.yaml''')
UpperCAmelCase__						:			Dict									=os.path.join(PATH, '''attributes.txt''')
UpperCAmelCase__						:			int									=os.path.join(PATH, '''objects.txt''')
UpperCAmelCase__						:			Tuple									=os.getenv('''PYTORCH_PRETRAINED_BERT_CACHE''', default_cache_path)
UpperCAmelCase__						:			int									=os.getenv('''PYTORCH_TRANSFORMERS_CACHE''', PYTORCH_PRETRAINED_BERT_CACHE)
UpperCAmelCase__						:			Optional[Any]									=os.getenv('''TRANSFORMERS_CACHE''', PYTORCH_TRANSFORMERS_CACHE)
UpperCAmelCase__						:			Dict									='''pytorch_model.bin'''
UpperCAmelCase__						:			List[Any]									='''config.yaml'''





def      _lowercase					(						_UpperCAmelCase=OBJECTS			,      _UpperCAmelCase=ATTRIBUTES				)						->  Tuple:
				lowerCamelCase	 =[]
				with open(_UpperCAmelCase				) as f:
								for object in f.readlines():
												vg_classes.append(object.split(""","""				)[0].lower().strip()				)

				lowerCamelCase	 =[]
				with open(_UpperCAmelCase				) as f:
								for object in f.readlines():
												vg_attrs.append(object.split(""","""				)[0].lower().strip()				)
				return vg_classes, vg_attrs





def      _lowercase					(						_UpperCAmelCase				)						->  Tuple:
				lowerCamelCase	 =OrderedDict()
				with open(_UpperCAmelCase			,      """rb"""				) as f:
								lowerCamelCase	 =pkl.load(_UpperCAmelCase				)["""model"""]
				for k in copy.deepcopy(list(ckp.keys()				)				):
								lowerCamelCase	 =ckp.pop(_UpperCAmelCase				)
								if isinstance(_UpperCAmelCase			,      np.ndarray				):
												lowerCamelCase	 =torch.tensor(_UpperCAmelCase				)
								else:
												assert isinstance(_UpperCAmelCase			,      torch.tensor				), type(_UpperCAmelCase				)
								lowerCamelCase	 =v
				return r

class       __A     :
				__A      =				{}


				def __init__(		self   , UpperCAmelCase_   , UpperCAmelCase_ = "root"   , UpperCAmelCase_=0							):
								lowerCamelCase	 =name
								lowerCamelCase	 =level
								lowerCamelCase	 ={}
								for k, v in dictionary.items():
												if v is None:
																raise ValueError()
												lowerCamelCase	 =copy.deepcopy(UpperCAmelCase_							)
												lowerCamelCase	 =copy.deepcopy(UpperCAmelCase_							)
												if isinstance(UpperCAmelCase_   , UpperCAmelCase_							):
																lowerCamelCase	 =Config(UpperCAmelCase_   , name=UpperCAmelCase_   , level=level + 1							)
												lowerCamelCase	 =v
												setattr(self   , UpperCAmelCase_   , UpperCAmelCase_							)

								lowerCamelCase	 =d


				def __repr__(		self							):
								return str(list((self._pointer.keys())							)							)


				def __setattr__(		self   , UpperCAmelCase_   , UpperCAmelCase_							):
								lowerCamelCase	 =val
								lowerCamelCase	 =val
								lowerCamelCase	 =key.split("""."""							)
								lowerCamelCase	 =len(UpperCAmelCase_							) - 1
								lowerCamelCase	 =self._pointer
								if len(UpperCAmelCase_							) > 1:
												for i, l in enumerate(UpperCAmelCase_							):
																if hasattr(self   , UpperCAmelCase_							) and isinstance(getattr(self   , UpperCAmelCase_							)   , UpperCAmelCase_							):
																				setattr(getattr(self   , UpperCAmelCase_							)   , """.""".join(levels[i:]							)   , UpperCAmelCase_							)
																if l == last_level:
																				lowerCamelCase	 =val
																else:
																				lowerCamelCase	 =pointer[l]


				def _snake_case       (		self							):
								return self._pointer


				def _snake_case       (		self   , UpperCAmelCase_   , UpperCAmelCase_							):
								with open(f"""{file_name}"""   , """w"""							) as stream:
												dump(UpperCAmelCase_   , UpperCAmelCase_							)


				def _snake_case       (		self   , UpperCAmelCase_   , UpperCAmelCase_							):
								with open(f"""{file_name}"""   , """w"""							) as stream:
												json.dump(UpperCAmelCase_   , UpperCAmelCase_							)


				@staticmethod
				def _snake_case       (		UpperCAmelCase_							):
								with open(UpperCAmelCase_							) as stream:
												lowerCamelCase	 =load(UpperCAmelCase_   , Loader=UpperCAmelCase_							)
								return data


				def __str__(		self							):
								lowerCamelCase	 ="""    """
								if self._name != "root":
												lowerCamelCase	 =f"""{t * (self._level-1)}{self._name}:\n"""
								else:
												lowerCamelCase	 =""""""
								lowerCamelCase	 =self._level
								for i, (k, v) in enumerate(self._pointer.items()							):
												if isinstance(UpperCAmelCase_   , UpperCAmelCase_							):
																r += f"""{t * (self._level)}{v}\n"""
																self._level += 1
												else:
																r += f"""{t * (self._level)}{k}: {v} ({type(UpperCAmelCase_							).__name__})\n"""
												lowerCamelCase	 =level
								return r[:-1]


				@classmethod
				def _snake_case       (		cls   , UpperCAmelCase_   , **UpperCAmelCase_							):
								lowerCamelCase ,  lowerCamelCase	 =cls.get_config_dict(UpperCAmelCase_   , **UpperCAmelCase_							)
								return cls(UpperCAmelCase_							)


				@classmethod
				def _snake_case       (		cls   , UpperCAmelCase_   , **UpperCAmelCase_							):
								lowerCamelCase	 =kwargs.pop("""cache_dir"""   , UpperCAmelCase_							)
								lowerCamelCase	 =kwargs.pop("""force_download"""   , UpperCAmelCase_							)
								lowerCamelCase	 =kwargs.pop("""resume_download"""   , UpperCAmelCase_							)
								lowerCamelCase	 =kwargs.pop("""proxies"""   , UpperCAmelCase_							)
								lowerCamelCase	 =kwargs.pop("""local_files_only"""   , UpperCAmelCase_							)

								if os.path.isdir(UpperCAmelCase_							):
												lowerCamelCase	 =os.path.join(UpperCAmelCase_   , UpperCAmelCase_							)
								elif os.path.isfile(UpperCAmelCase_							) or is_remote_url(UpperCAmelCase_							):
												lowerCamelCase	 =pretrained_model_name_or_path
								else:
												lowerCamelCase	 =hf_bucket_url(UpperCAmelCase_   , filename=UpperCAmelCase_   , use_cdn=UpperCAmelCase_							)

								try:
												# Load from URL or cache if already cached
												lowerCamelCase	 =cached_path(
												    UpperCAmelCase_   , cache_dir=UpperCAmelCase_   , force_download=UpperCAmelCase_   , proxies=UpperCAmelCase_   , resume_download=UpperCAmelCase_   , local_files_only=UpperCAmelCase_   , )
												# Load config dict
												if resolved_config_file is None:
																raise EnvironmentError

												lowerCamelCase	 =Config.load_yaml(UpperCAmelCase_							)

								except EnvironmentError:
												lowerCamelCase	 ="""Can't load config for"""
												raise EnvironmentError(UpperCAmelCase_							)

								if resolved_config_file == config_file:
												print("""loading configuration file from path"""							)
								else:
												print("""loading configuration file cache"""							)

								return Config.load_yaml(UpperCAmelCase_							), kwargs





def      _lowercase					(						_UpperCAmelCase				)						->  List[Any]:
				lowerCamelCase	 =torch.load("""dump.pt"""			,      map_location=in_tensor.device				)
				lowerCamelCase	 =in_tensor.numpy()
				lowerCamelCase	 =out_tensor.numpy()[0]
				print(na.shape			,      na[0, 0, :5]				)
				print(na.shape			,      na[0, 0, :5]				)
				assert np.allclose(_UpperCAmelCase			,      _UpperCAmelCase			,      rtol=0.0_1			,      atol=0.1				), (
				    F"""{sum([1 for x in np.isclose(_UpperCAmelCase			,      _UpperCAmelCase			,      rtol=0.0_1			,      atol=0.1				).flatten() if x is False]				)/len(na.flatten()				)*1_00:.4f} %"""
				    " element-wise mismatch"
				)
				raise Exception("""tensors are all good"""				)

				# Hugging face functions below





def      _lowercase					(						_UpperCAmelCase				)						->  int:
				lowerCamelCase	 =urlparse(_UpperCAmelCase				)
				return parsed.scheme in ("http", "https")





def      _lowercase					(						_UpperCAmelCase			,      _UpperCAmelCase			,      _UpperCAmelCase=True				)						->  str:
				lowerCamelCase	 =CLOUDFRONT_DISTRIB_PREFIX if use_cdn else S3_BUCKET_PREFIX
				lowerCamelCase	 ="""/""" not in model_id
				if legacy_format:
								return F"""{endpoint}/{model_id}-{filename}"""
				else:
								return F"""{endpoint}/{model_id}/{filename}"""





def      _lowercase					(						_UpperCAmelCase			,      _UpperCAmelCase			,      _UpperCAmelCase=None			,      _UpperCAmelCase=0			,      _UpperCAmelCase=None			,      )						->  List[Any]:
				lowerCamelCase	 ="""python/{}""".format(sys.version.split()[0]				)
				if _torch_available:
								ua += "; torch/{}".format(torch.__version__				)
				if isinstance(_UpperCAmelCase			,      _UpperCAmelCase				):
								ua += "; " + "; ".join("""{}/{}""".format(_UpperCAmelCase			,      _UpperCAmelCase				) for k, v in user_agent.items()				)
				elif isinstance(_UpperCAmelCase			,      _UpperCAmelCase				):
								ua += "; " + user_agent
				lowerCamelCase	 ={"""user-agent""": ua}
				if resume_size > 0:
								lowerCamelCase	 ="""bytes=%d-""" % (resume_size,)
				lowerCamelCase	 =requests.get(_UpperCAmelCase			,      stream=_UpperCAmelCase			,      proxies=_UpperCAmelCase			,      headers=_UpperCAmelCase				)
				if response.status_code == 4_16:  # Range not satisfiable
								return
				lowerCamelCase	 =response.headers.get("""Content-Length"""				)
				lowerCamelCase	 =resume_size + int(_UpperCAmelCase				) if content_length is not None else None
				lowerCamelCase	 =tqdm(
				    unit="""B"""			,      unit_scale=_UpperCAmelCase			,      total=_UpperCAmelCase			,      initial=_UpperCAmelCase			,      desc="""Downloading"""			,      )
				for chunk in response.iter_content(chunk_size=10_24				):
								if chunk:  # filter out keep-alive new chunks
												progress.update(len(_UpperCAmelCase				)				)
												temp_file.write(_UpperCAmelCase				)
				progress.close()





def      _lowercase					(						_UpperCAmelCase			,      _UpperCAmelCase=None			,      _UpperCAmelCase=False			,      _UpperCAmelCase=None			,      _UpperCAmelCase=10			,      _UpperCAmelCase=False			,      _UpperCAmelCase=None			,      _UpperCAmelCase=False			,      )						->  Optional[int]:
				if cache_dir is None:
								lowerCamelCase	 =TRANSFORMERS_CACHE
				if isinstance(_UpperCAmelCase			,      _UpperCAmelCase				):
								lowerCamelCase	 =str(_UpperCAmelCase				)

				os.makedirs(_UpperCAmelCase			,      exist_ok=_UpperCAmelCase				)

				lowerCamelCase	 =None
				if not local_files_only:
								try:
												lowerCamelCase	 =requests.head(_UpperCAmelCase			,      allow_redirects=_UpperCAmelCase			,      proxies=_UpperCAmelCase			,      timeout=_UpperCAmelCase				)
												if response.status_code == 2_00:
																lowerCamelCase	 =response.headers.get("""ETag"""				)
								except (EnvironmentError, requests.exceptions.Timeout):
												# etag is already None
												pass

				lowerCamelCase	 =url_to_filename(_UpperCAmelCase			,      _UpperCAmelCase				)

				# get cache path to put the file
				lowerCamelCase	 =os.path.join(_UpperCAmelCase			,      _UpperCAmelCase				)

				# etag is None = we don't have a connection, or url doesn't exist, or is otherwise inaccessible.
				# try to get the last downloaded one
				if etag is None:
								if os.path.exists(_UpperCAmelCase				):
												return cache_path
								else:
												lowerCamelCase	 =[
												    file
												    for file in fnmatch.filter(os.listdir(_UpperCAmelCase				)			,      filename + """.*"""				)
												    if not file.endswith(""".json"""				) and not file.endswith(""".lock"""				)
												]
												if len(_UpperCAmelCase				) > 0:
																return os.path.join(_UpperCAmelCase			,      matching_files[-1]				)
												else:
																# If files cannot be found and local_files_only=True,
																# the models might've been found if local_files_only=False
																# Notify the user about that
																if local_files_only:
																				raise ValueError(
																				    """Cannot find the requested files in the cached path and outgoing traffic has been"""
																				    """ disabled. To enable model look-ups and downloads online, set 'local_files_only'"""
																				    """ to False."""				)
																return None

    # From now on, etag is not None.
				if os.path.exists(_UpperCAmelCase				) and not force_download:
								return cache_path

				# Prevent parallel downloads of the same file with a lock.
				lowerCamelCase	 =cache_path + """.lock"""
				with FileLock(_UpperCAmelCase				):
								# If the download just completed while the lock was activated.
								if os.path.exists(_UpperCAmelCase				) and not force_download:
												# Even if returning early like here, the lock will be released.
												return cache_path

								if resume_download:
												lowerCamelCase	 =cache_path + """.incomplete"""

												@contextmanager
												def _resumable_file_manager():
																with open(_UpperCAmelCase			,      """a+b"""				) as f:
																				yield f

												lowerCamelCase	 =_resumable_file_manager
												if os.path.exists(_UpperCAmelCase				):
																lowerCamelCase	 =os.stat(_UpperCAmelCase				).st_size
												else:
																lowerCamelCase	 =0
								else:
												lowerCamelCase	 =partial(tempfile.NamedTemporaryFile			,      dir=_UpperCAmelCase			,      delete=_UpperCAmelCase				)
												lowerCamelCase	 =0

								# Download to temporary file, then copy to cache dir once finished.
								# Otherwise you get corrupt cache entries if the download gets interrupted.
								with temp_file_manager() as temp_file:
												print(
												    """%s not found in cache or force_download set to True, downloading to %s"""			,      _UpperCAmelCase			,      temp_file.name			,      )

												http_get(
												    _UpperCAmelCase			,      _UpperCAmelCase			,      proxies=_UpperCAmelCase			,      resume_size=_UpperCAmelCase			,      user_agent=_UpperCAmelCase			,      )

								os.replace(temp_file.name			,      _UpperCAmelCase				)

								lowerCamelCase	 ={"""url""": url, """etag""": etag}
								lowerCamelCase	 =cache_path + """.json"""
								with open(_UpperCAmelCase			,      """w"""				) as meta_file:
												json.dump(_UpperCAmelCase			,      _UpperCAmelCase				)

				return cache_path





def      _lowercase					(						_UpperCAmelCase			,      _UpperCAmelCase=None				)						->  Dict:
				lowerCamelCase	 =url.encode("""utf-8"""				)
				lowerCamelCase	 =shaaaa(_UpperCAmelCase				)
				lowerCamelCase	 =url_hash.hexdigest()

				if etag:
								lowerCamelCase	 =etag.encode("""utf-8"""				)
								lowerCamelCase	 =shaaaa(_UpperCAmelCase				)
								filename += "." + etag_hash.hexdigest()

				if url.endswith(""".h5"""				):
								filename += ".h5"

				return filename





def      _lowercase					(						_UpperCAmelCase			,      _UpperCAmelCase=None			,      _UpperCAmelCase=False			,      _UpperCAmelCase=None			,      _UpperCAmelCase=False			,      _UpperCAmelCase=None			,      _UpperCAmelCase=False			,      _UpperCAmelCase=False			,      _UpperCAmelCase=False			,      )						->  Tuple:
				if cache_dir is None:
								lowerCamelCase	 =TRANSFORMERS_CACHE
				if isinstance(_UpperCAmelCase			,      _UpperCAmelCase				):
								lowerCamelCase	 =str(_UpperCAmelCase				)
				if isinstance(_UpperCAmelCase			,      _UpperCAmelCase				):
								lowerCamelCase	 =str(_UpperCAmelCase				)

				if is_remote_url(_UpperCAmelCase				):
								# URL, so get it from the cache (downloading if necessary)
								lowerCamelCase	 =get_from_cache(
								    _UpperCAmelCase			,      cache_dir=_UpperCAmelCase			,      force_download=_UpperCAmelCase			,      proxies=_UpperCAmelCase			,      resume_download=_UpperCAmelCase			,      user_agent=_UpperCAmelCase			,      local_files_only=_UpperCAmelCase			,      )
				elif os.path.exists(_UpperCAmelCase				):
								# File, and it exists.
								lowerCamelCase	 =url_or_filename
				elif urlparse(_UpperCAmelCase				).scheme == "":
								# File, but it doesn't exist.
								raise EnvironmentError("""file {} not found""".format(_UpperCAmelCase				)				)
				else:
								# Something unknown
								raise ValueError("""unable to parse {} as a URL or as a local path""".format(_UpperCAmelCase				)				)

				if extract_compressed_file:
								if not is_zipfile(_UpperCAmelCase				) and not tarfile.is_tarfile(_UpperCAmelCase				):
												return output_path

								# Path where we extract compressed archives
								# We avoid '.' in dir name and add "-extracted" at the end: "./model.zip" => "./model-zip-extracted/"
								lowerCamelCase ,  lowerCamelCase	 =os.path.split(_UpperCAmelCase				)
								lowerCamelCase	 =output_file.replace("""."""			,      """-"""				) + """-extracted"""
								lowerCamelCase	 =os.path.join(_UpperCAmelCase			,      _UpperCAmelCase				)

								if os.path.isdir(_UpperCAmelCase				) and os.listdir(_UpperCAmelCase				) and not force_extract:
												return output_path_extracted

								# Prevent parallel extractions
								lowerCamelCase	 =output_path + """.lock"""
								with FileLock(_UpperCAmelCase				):
												shutil.rmtree(_UpperCAmelCase			,      ignore_errors=_UpperCAmelCase				)
												os.makedirs(_UpperCAmelCase				)
												if is_zipfile(_UpperCAmelCase				):
																with ZipFile(_UpperCAmelCase			,      """r"""				) as zip_file:
																				zip_file.extractall(_UpperCAmelCase				)
																				zip_file.close()
												elif tarfile.is_tarfile(_UpperCAmelCase				):
																lowerCamelCase	 =tarfile.open(_UpperCAmelCase				)
																tar_file.extractall(_UpperCAmelCase				)
																tar_file.close()
												else:
																raise EnvironmentError("""Archive format of {} could not be identified""".format(_UpperCAmelCase				)				)

								return output_path_extracted

				return output_path





def      _lowercase					(						_UpperCAmelCase			,      _UpperCAmelCase=","				)						->  Dict:
				assert isinstance(_UpperCAmelCase			,      _UpperCAmelCase				)
				if os.path.isfile(_UpperCAmelCase				):
								with open(_UpperCAmelCase				) as f:
												lowerCamelCase	 =eval(f.read()				)
				else:
								lowerCamelCase	 =requests.get(_UpperCAmelCase				)
								try:
												lowerCamelCase	 =requests.json()
								except Exception:
												lowerCamelCase	 =req.content.decode()
												assert data is not None, "could not connect"
												try:
																lowerCamelCase	 =eval(_UpperCAmelCase				)
												except Exception:
																lowerCamelCase	 =data.split("""\n"""				)
								req.close()
				return data





def      _lowercase					(						_UpperCAmelCase				)						->  str:
				lowerCamelCase	 =requests.get(_UpperCAmelCase				)
				lowerCamelCase	 =np.array(Image.open(BytesIO(response.content				)				)				)
				return img





def      _lowercase					(						_UpperCAmelCase				)						->  Tuple:
				lowerCamelCase	 =url.split("""/"""				)[-1]
				if fn not in os.listdir(os.getcwd()				):
								wget.download(_UpperCAmelCase				)
				with open(_UpperCAmelCase			,      """rb"""				) as stream:
								lowerCamelCase	 =pkl.load(_UpperCAmelCase				)
				lowerCamelCase	 =weights.pop("""model"""				)
				lowerCamelCase	 ={}
				for k, v in model.items():
								lowerCamelCase	 =torch.from_numpy(_UpperCAmelCase				)
								if "running_var" in k:
												lowerCamelCase	 =torch.tensor([0]				)
												lowerCamelCase	 =k.replace("""running_var"""			,      """num_batches_tracked"""				)
												lowerCamelCase	 =zero
				return new





def      _lowercase					(						)						->  int:
				print(F"""{os.path.abspath(os.path.join(_UpperCAmelCase			,      os.pardir				)				)}/demo.ipynb"""				)





def      _lowercase					(						_UpperCAmelCase			,      _UpperCAmelCase="RGB"				)						->  Optional[Any]:
				assert isinstance(_UpperCAmelCase			,      _UpperCAmelCase				)
				if os.path.isfile(_UpperCAmelCase				):
								lowerCamelCase	 =cva.imread(_UpperCAmelCase				)
				else:
								lowerCamelCase	 =get_image_from_url(_UpperCAmelCase				)
								assert img is not None, F"""could not connect to: {im}"""
				lowerCamelCase	 =cva.cvtColor(_UpperCAmelCase			,      cva.COLOR_BGR2RGB				)
				if input_format == "RGB":
								lowerCamelCase	 =img[:, :, ::-1]
				return img





def      _lowercase					(						_UpperCAmelCase			,      _UpperCAmelCase=1				)						->  str:
				return (images[i : i + batch] for i in range(0			,      len(_UpperCAmelCase				)			,      _UpperCAmelCase				))












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   , UpperCAmelCase_   , UpperCAmelCase_=13   , UpperCAmelCase_=32   , UpperCAmelCase_=2   , UpperCAmelCase_=3   , UpperCAmelCase_=16   , UpperCAmelCase_=[32, 64, 128]   , UpperCAmelCase_=[1, 2, 1]   , UpperCAmelCase_=[2, 2, 4]   , UpperCAmelCase_=2   , UpperCAmelCase_=2.0   , UpperCAmelCase_=True   , UpperCAmelCase_=0.0   , UpperCAmelCase_=0.0   , UpperCAmelCase_=0.1   , UpperCAmelCase_="gelu"   , UpperCAmelCase_=False   , UpperCAmelCase_=True   , UpperCAmelCase_=0.0_2   , UpperCAmelCase_=1E-5   , UpperCAmelCase_=True   , UpperCAmelCase_=None   , UpperCAmelCase_=True   , UpperCAmelCase_=10   , UpperCAmelCase_=8   , UpperCAmelCase_=["stage1", "stage2"]   , UpperCAmelCase_=[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 _snake_case       (		self							):
								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 _snake_case       (		self							):
								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 _snake_case       (		self   , UpperCAmelCase_   , UpperCAmelCase_   , UpperCAmelCase_							):
								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 _snake_case       (		self   , UpperCAmelCase_   , UpperCAmelCase_   , UpperCAmelCase_							):
								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 _snake_case       (		self   , UpperCAmelCase_   , UpperCAmelCase_   , UpperCAmelCase_							):
								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 _snake_case       (		self   , UpperCAmelCase_   , UpperCAmelCase_   , UpperCAmelCase_							):
								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 _snake_case       (		self							):
								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     (						a    ,					a    ,					unittest.TestCase    ):
				__A      =				(
				    (
				        FocalNetModel,
				        FocalNetForImageClassification,
				        FocalNetForMaskedImageModeling,
				        FocalNetBackbone,
				    )
				    if is_torch_available()
				    else ()
				)
				__A      =				(
				    {"""feature-extraction""": FocalNetModel, """image-classification""": FocalNetForImageClassification}
				    if is_torch_available()
				    else {}
				)
				__A      =				False

				__A      =				False
				__A      =				False
				__A      =				False
				__A      =				False


				def _snake_case       (		self							):
								lowerCamelCase	 =FocalNetModelTester(self							)
								lowerCamelCase	 =ConfigTester(self   , config_class=UpperCAmelCase_   , embed_dim=37   , has_text_modality=UpperCAmelCase_							)


				def _snake_case       (		self							):
								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 _snake_case       (		self							):
								return


				def _snake_case       (		self							):
								lowerCamelCase	 =self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*UpperCAmelCase_							)


				def _snake_case       (		self							):
								lowerCamelCase	 =self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_backbone(*UpperCAmelCase_							)


				def _snake_case       (		self							):
								lowerCamelCase	 =self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_masked_image_modeling(*UpperCAmelCase_							)


				def _snake_case       (		self							):
								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 _snake_case       (		self							):
								pass


				@unittest.skip(reason="""FocalNet does not use feedforward chunking"""							)
				def _snake_case       (		self							):
								pass


				def _snake_case       (		self							):
								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 _snake_case       (		self							):
								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 _snake_case       (		self   , UpperCAmelCase_   , UpperCAmelCase_   , UpperCAmelCase_   , UpperCAmelCase_							):
								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 _snake_case       (		self							):
								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 _snake_case       (		self							):
								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 _snake_case       (		self							):
								for model_name in FOCALNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												lowerCamelCase	 =FocalNetModel.from_pretrained(UpperCAmelCase_							)
												self.assertIsNotNone(UpperCAmelCase_							)


				def _snake_case       (		self							):
								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 _snake_case       (		self							):
								# TODO update organization
								return AutoImageProcessor.from_pretrained("""microsoft/focalnet-tiny"""							) if is_vision_available() else None


				@slow
				def _snake_case       (		self							):
								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, 1000)							)
								self.assertEqual(outputs.logits.shape   , UpperCAmelCase_							)
								lowerCamelCase	 =torch.tensor([0.2_1_6_6, -0.4_3_6_8, 0.2_1_9_1]							).to(UpperCAmelCase_							)
								self.assertTrue(torch.allclose(outputs.logits[0, :3]   , UpperCAmelCase_   , atol=1E-4							)							)
								self.assertTrue(outputs.logits.argmax(dim=-1							).item()   , 281							)




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

				__A      =				False


				def _snake_case       (		self							):
								lowerCamelCase	 =FocalNetModelTester(self							)





