
"""simple docstring"""





import os
import re
import sys
import traceback
import warnings
from pathlib import Path
from typing import Dict, Optional, Union
from uuid import uuida

from huggingface_hub import HfFolder, ModelCard, ModelCardData, hf_hub_download, whoami
from huggingface_hub.file_download import REGEX_COMMIT_HASH
from huggingface_hub.utils import (
    EntryNotFoundError,
    RepositoryNotFoundError,
    RevisionNotFoundError,
    is_jinja_available,
)
from packaging import version
from requests import HTTPError

from .. import __version__
from .constants import (
    DEPRECATED_REVISION_ARGS,
    DIFFUSERS_CACHE,
    HUGGINGFACE_CO_RESOLVE_ENDPOINT,
    SAFETENSORS_WEIGHTS_NAME,
    WEIGHTS_NAME,
)
from .import_utils import (
    ENV_VARS_TRUE_VALUES,
    _flax_version,
    _jax_version,
    _onnxruntime_version,
    _torch_version,
    is_flax_available,
    is_onnx_available,
    is_torch_available,
)
from .logging import get_logger


UpperCamelCase_       :    Dict						      =			get_logger(__name__)


UpperCamelCase_       :    Tuple						      =			Path(__file__).parent / '''model_card_template.md'''
UpperCamelCase_       :    Any						      =			uuida().hex
UpperCamelCase_       :    Any						      =			os.getenv('''HF_HUB_OFFLINE''', '''''').upper() in ENV_VARS_TRUE_VALUES
UpperCamelCase_       :    List[Any]						      =			os.getenv('''DISABLE_TELEMETRY''', '''''').upper() in ENV_VARS_TRUE_VALUES
UpperCamelCase_       :    Any						      =			HUGGINGFACE_CO_RESOLVE_ENDPOINT + '''/api/telemetry/'''
def 				A_  (__a = None					):

					'''simple docstring'''





					A_								=    f'diffusers/{__version__}; python/{sys.version.split()[0]}; session_id/{SESSION_ID}'
					if DISABLE_TELEMETRY or HF_HUB_OFFLINE:
										return ua + "; telemetry/off"
					if is_torch_available():
										ua += f'; torch/{_torch_version}'
					if is_flax_available():
										ua += f'; jax/{_jax_version}'
										ua += f'; flax/{_flax_version}'
					if is_onnx_available():
										ua += f'; onnxruntime/{_onnxruntime_version}'
					# CI will set this value to True
					if os.environ.get("DIFFUSERS_IS_CI"					, ""					).upper() in ENV_VARS_TRUE_VALUES:
										ua += "; is_ci/true"
					if isinstance(__a					, __a					):
										ua += "; " + "; ".join(f'{k}/{v}' for k, v in user_agent.items()					)
					elif isinstance(__a					, __a					):
										ua += "; " + user_agent
					return ua
def 				A_  (__a					, __a = None					, __a = None					):

					'''simple docstring'''





					if token is None:
										A_								=    HfFolder.get_token()
					if organization is None:
										A_								=    whoami(__a					)["name"]
										return f'{username}/{model_id}'
					else:
										return f'{organization}/{model_id}'
def 				A_  (__a					, __a					):

					'''simple docstring'''





					if not is_jinja_available():
										raise ValueError(
										    "Modelcard rendering is based on Jinja templates."
										    " Please make sure to have `jinja` installed before using `create_model_card`."
										    " To install it, please run `pip install Jinja2`."					)

					if hasattr(__a					, "local_rank"					) and args.local_rank not in [-1, 0]:
										return

					A_								=    args.hub_token if hasattr(__a					, "hub_token"					) else None
					A_								=    get_full_repo_name(__a					, token=__a					)

					A_								=    ModelCard.from_template(
					    card_data=ModelCardData(  # Card metadata object that will be converted to YAML block
					        language="en"					, license="apache-2.0"					, library_name="diffusers"					, tags=[]					, datasets=args.dataset_name					, metrics=[]					, )					, template_path=__a					, model_name=__a					, repo_name=__a					, dataset_name=args.dataset_name if hasattr(__a					, "dataset_name"					) else None					, learning_rate=args.learning_rate					, train_batch_size=args.train_batch_size					, eval_batch_size=args.eval_batch_size					, gradient_accumulation_steps=(
					        args.gradient_accumulation_steps if hasattr(__a					, "gradient_accumulation_steps"					) else None
					    )					, adam_betaa=args.adam_betaa if hasattr(__a					, "adam_beta1"					) else None					, adam_betaa=args.adam_betaa if hasattr(__a					, "adam_beta2"					) else None					, adam_weight_decay=args.adam_weight_decay if hasattr(__a					, "adam_weight_decay"					) else None					, adam_epsilon=args.adam_epsilon if hasattr(__a					, "adam_epsilon"					) else None					, lr_scheduler=args.lr_scheduler if hasattr(__a					, "lr_scheduler"					) else None					, lr_warmup_steps=args.lr_warmup_steps if hasattr(__a					, "lr_warmup_steps"					) else None					, ema_inv_gamma=args.ema_inv_gamma if hasattr(__a					, "ema_inv_gamma"					) else None					, ema_power=args.ema_power if hasattr(__a					, "ema_power"					) else None					, ema_max_decay=args.ema_max_decay if hasattr(__a					, "ema_max_decay"					) else None					, mixed_precision=args.mixed_precision					, )

					A_								=    os.path.join(args.output_dir					, "README.md"					)
					model_card.save(__a					)
def 				A_  (__a					, __a = None					):

					'''simple docstring'''





					if resolved_file is None or commit_hash is not None:
										return commit_hash
					A_								=    str(Path(__a					).as_posix()					)
					A_								=    re.search(R"snapshots/([^/]+)/"					, __a					)
					if search is None:
										return None
					A_								=    search.groups()[0]
					return commit_hash if REGEX_COMMIT_HASH.match(__a					) else None


# Old default cache path, potentially to be migrated.
# This logic was more or less taken from `transformers`, with the following differences:
# - Diffusers doesn't use custom environment variables to specify the cache path.
# - There is no need to migrate the cache format, just move the files to the new location.
UpperCamelCase_       :    Union[str, Any]						      =			os.path.expanduser(
    os.getenv('''HF_HOME''', os.path.join(os.getenv('''XDG_CACHE_HOME''', '''~/.cache'''), '''huggingface'''))
)
UpperCamelCase_       :    Optional[int]						      =			os.path.join(hf_cache_home, '''diffusers''')
def 				A_  (__a = None					, __a = None					):

					'''simple docstring'''





					if new_cache_dir is None:
										A_								=    DIFFUSERS_CACHE
					if old_cache_dir is None:
										A_								=    old_diffusers_cache

					A_								=    Path(__a					).expanduser()
					A_								=    Path(__a					).expanduser()
					for old_blob_path in old_cache_dir.glob("**/blobs/*"					):
										if old_blob_path.is_file() and not old_blob_path.is_symlink():
															A_								=    new_cache_dir / old_blob_path.relative_to(__a					)
															new_blob_path.parent.mkdir(parents=__a					, exist_ok=__a					)
															os.replace(__a					, __a					)
															try:
																				os.symlink(__a					, __a					)
															except OSError:
																				logger.warning(
																				    "Could not create symlink between old cache and new cache. If you use an older version of diffusers again, files will be re-downloaded."					)
					# At this point, old_cache_dir contains symlinks to the new cache (it can still be used).


UpperCamelCase_       :    Dict						      =			os.path.join(DIFFUSERS_CACHE, '''version_diffusers_cache.txt''')
if not os.path.isfile(cache_version_file):
		UpperCamelCase_       :    Dict						      =			0
else:
		with open(cache_version_file) as f:
				try:
						UpperCamelCase_       :    Optional[Any]						      =			int(f.read())
				except ValueError:
						UpperCamelCase_       :    Union[str, Any]						      =			0

if cache_version < 1:
		UpperCamelCase_       :    Any						      =			os.path.isdir(old_diffusers_cache) and len(os.listdir(old_diffusers_cache)) > 0
		if old_cache_is_not_empty:
				logger.warning(
				    '''The cache for model files in Diffusers v0.14.0 has moved to a new location. Moving your '''
				    '''existing cached models. This is a one-time operation, you can interrupt it or run it '''
				    '''later by calling `diffusers.utils.hub_utils.move_cache()`.'''
				)
				try:
						move_cache()
				except Exception as e:
						UpperCamelCase_       :    Optional[Any]						      =			'''\n'''.join(traceback.format_tb(e.__traceback__))
						logger.error(
						    F"""There was a problem when trying to move your cache:\n\n{trace}\n{e.__class__.__name__}: {e}\n\nPlease """
						    '''file an issue at https://github.com/huggingface/diffusers/issues/new/choose, copy paste this whole '''
						    '''message and we will do our best to help.'''
						)

if cache_version < 1:
		try:
				os.makedirs(DIFFUSERS_CACHE, exist_ok=True)
				with open(cache_version_file, '''w''') as f:
						f.write('''1''')
		except Exception:
				logger.warning(
				    F"""There was a problem when trying to write in your cache folder ({DIFFUSERS_CACHE}). Please, ensure """
				    '''the directory exists and can be written to.'''
				)
def 				A_  (__a					, __a = None					):

					'''simple docstring'''





					if variant is not None:
										A_								=    weights_name.split("."					)
										A_								=    splits[:-1] + [variant] + splits[-1:]
										A_								=    ".".join(__a					)

					return weights_name




def 				A_  (__a					, *,
    __a					, __a					, __a					, __a					, __a					, __a					, __a					, __a					, __a					, __a					, __a=None					, ):

					'''simple docstring'''





					A_								=    str(__a					)
					if os.path.isfile(__a					):
										return pretrained_model_name_or_path
					elif os.path.isdir(__a					):
										if os.path.isfile(os.path.join(__a					, __a					)					):
															# Load from a PyTorch checkpoint
															A_								=    os.path.join(__a					, __a					)
															return model_file
										elif subfolder is not None and os.path.isfile(
										    os.path.join(__a					, __a					, __a					)					):
															A_								=    os.path.join(__a					, __a					, __a					)
															return model_file
										else:
															raise EnvironmentError(
															    f'Error no file named {weights_name} found in directory {pretrained_model_name_or_path}.'					)
					else:
										# 1. First check if deprecated way of loading from branches is used
										if (
										    revision in DEPRECATED_REVISION_ARGS
										    and (weights_name == WEIGHTS_NAME or weights_name == SAFETENSORS_WEIGHTS_NAME)
										    and version.parse(version.parse(__a					).base_version					) >= version.parse("0.20.0"					)
										):
															try:
																				A_								=    hf_hub_download(
																				    __a					, filename=_add_variant(__a					, __a					)					, cache_dir=__a					, force_download=__a					, proxies=__a					, resume_download=__a					, local_files_only=__a					, use_auth_token=__a					, user_agent=__a					, subfolder=__a					, revision=revision or commit_hash					, )
																				warnings.warn(
																				    f'Loading the variant {revision} from {pretrained_model_name_or_path} via `revision=\'{revision}\'` is deprecated. Loading instead from `revision=\'main\'` with `variant={revision}`. Loading model variants via `revision=\'{revision}\'` will be removed in diffusers v1. Please use `variant=\'{revision}\'` instead.'					, __a					, )
																				return model_file
															except:  # noqa: E722
																				warnings.warn(
																				    f'You are loading the variant {revision} from {pretrained_model_name_or_path} via `revision=\'{revision}\'`. This behavior is deprecated and will be removed in diffusers v1. One should use `variant=\'{revision}\'` instead. However, it appears that {pretrained_model_name_or_path} currently does not have a {_add_variant(__a					, __a					)} file in the \'main\' branch of {pretrained_model_name_or_path}. \n The Diffusers team and community would be very grateful if you could open an issue: https://github.com/huggingface/diffusers/issues/new with the title \'{pretrained_model_name_or_path} is missing {_add_variant(__a					, __a					)}\' so that the correct variant file can be added.'					, __a					, )
										try:
															# 2. Load model file as usual
															A_								=    hf_hub_download(
															    __a					, filename=__a					, cache_dir=__a					, force_download=__a					, proxies=__a					, resume_download=__a					, local_files_only=__a					, use_auth_token=__a					, user_agent=__a					, subfolder=__a					, revision=revision or commit_hash					, )
															return model_file

										except RepositoryNotFoundError:
															raise EnvironmentError(
															    f'{pretrained_model_name_or_path} is not a local folder and is not a valid model identifier '
															    "listed on 'https://huggingface.co/models'\nIf this is a private repository, make sure to pass a "
															    "token having permission to this repo with `use_auth_token` or log in with `huggingface-cli "
															    "login`."					)
										except RevisionNotFoundError:
															raise EnvironmentError(
															    f'{revision} is not a valid git identifier (branch name, tag name or commit id) that exists for '
															    "this model name. Check the model page at "
															    f'\'https://huggingface.co/{pretrained_model_name_or_path}\' for available revisions.'					)
										except EntryNotFoundError:
															raise EnvironmentError(
															    f'{pretrained_model_name_or_path} does not appear to have a file named {weights_name}.'					)
										except HTTPError as err:
															raise EnvironmentError(
															    f'There was a specific connection error when trying to load {pretrained_model_name_or_path}:\n{err}'					)
										except ValueError:
															raise EnvironmentError(
															    f'We couldn\'t connect to \'{HUGGINGFACE_CO_RESOLVE_ENDPOINT}\' to load this model, couldn\'t find it'
															    f' in the cached files and it looks like {pretrained_model_name_or_path} is not the path to a'
															    f' directory containing a file named {weights_name} or'
															    " \nCheckout your internet connection or see how to run the library in"
															    " offline mode at 'https://huggingface.co/docs/diffusers/installation#offline-mode'."					)
										except EnvironmentError:
															raise EnvironmentError(
															    f'Can\'t load the model for \'{pretrained_model_name_or_path}\'. If you were trying to load it from '
															    "'https://huggingface.co/models', make sure you don't have a local directory with the same name. "
															    f'Otherwise, make sure \'{pretrained_model_name_or_path}\' is the correct path to a directory '
															    f'containing a file named {weights_name}'					)






"""simple docstring"""





import inspect
import unittest

from transformers import YolosConfig
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_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
		import torch
		from torch import nn

		from transformers import YolosForObjectDetection, YolosModel
		from transformers.models.yolos.modeling_yolos import YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
		from PIL import Image

		from transformers import AutoImageProcessor



class __lowerCAmelCase					:




			"""simple docstring"""







			def __init__(					self    :       Union[str, Any]							, _snake_case    :       Optional[Any]							, _snake_case    :       Any=13							, _snake_case    :       Union[str, Any]=[30, 30]							, _snake_case    :       Optional[int]=2							, _snake_case    :       str=3							, _snake_case    :       List[str]=True							, _snake_case    :       Tuple=True							, _snake_case    :       Union[str, Any]=32							, _snake_case    :       List[str]=5							, _snake_case    :       str=4							, _snake_case    :       Tuple=37							, _snake_case    :       Tuple="gelu"							, _snake_case    :       str=0.1							, _snake_case    :       Tuple=0.1							, _snake_case    :       Optional[Any]=10							, _snake_case    :       Dict=0.0_2							, _snake_case    :       int=3							, _snake_case    :       Optional[int]=None							, _snake_case    :       str=8							, _snake_case    :       Dict=10							, )   ->			int:







								"""simple docstring"""
								A_								=    parent
								A_								=    batch_size
								A_								=    image_size
								A_								=    patch_size
								A_								=    num_channels
								A_								=    is_training
								A_								=    use_labels
								A_								=    hidden_size
								A_								=    num_hidden_layers
								A_								=    num_attention_heads
								A_								=    intermediate_size
								A_								=    hidden_act
								A_								=    hidden_dropout_prob
								A_								=    attention_probs_dropout_prob
								A_								=    type_sequence_label_size
								A_								=    initializer_range
								A_								=    num_labels
								A_								=    scope
								A_								=    n_targets
								A_								=    num_detection_tokens
								# we set the expected sequence length (which is used in several tests)
								# expected sequence length = num_patches + 1 (we add 1 for the [CLS] token) + num_detection_tokens
								A_								=    (image_size[1] // patch_size) * (image_size[0] // patch_size)
								A_								=    num_patches + 1 + self.num_detection_tokens




			def   lowerCamelCase__  (					self    :       Any						)   ->			str:







								"""simple docstring"""
								A_								=    floats_tensor([self.batch_size, self.num_channels, self.image_size[0], self.image_size[1]]						)

								A_								=    None
								if self.use_labels:
													# labels is a list of Dict (each Dict being the labels for a given example in the batch)
													A_								=    []
													for i in range(self.batch_size						):
																		A_								=    {}
																		A_								=    torch.randint(
																		    high=self.num_labels							, size=(self.n_targets,)							, device=_snake_case						)
																		A_								=    torch.rand(self.n_targets							, 4							, device=_snake_case						)
																		labels.append(_snake_case						)

								A_								=    self.get_config()

								return config, pixel_values, labels




			def   lowerCamelCase__  (					self    :       List[str]						)   ->			str:







								"""simple docstring"""
								return YolosConfig(
								    image_size=self.image_size							, patch_size=self.patch_size							, num_channels=self.num_channels							, hidden_size=self.hidden_size							, num_hidden_layers=self.num_hidden_layers							, num_attention_heads=self.num_attention_heads							, intermediate_size=self.intermediate_size							, hidden_act=self.hidden_act							, hidden_dropout_prob=self.hidden_dropout_prob							, attention_probs_dropout_prob=self.attention_probs_dropout_prob							, is_decoder=_snake_case							, initializer_range=self.initializer_range							, num_detection_tokens=self.num_detection_tokens							, num_labels=self.num_labels							, )




			def   lowerCamelCase__  (					self    :       Any							, _snake_case    :       Union[str, Any]							, _snake_case    :       Optional[Any]							, _snake_case    :       Union[str, Any]						)   ->			List[str]:







								"""simple docstring"""
								A_								=    YolosModel(config=_snake_case						)
								model.to(_snake_case						)
								model.eval()
								A_								=    model(_snake_case						)
								self.parent.assertEqual(
								    result.last_hidden_state.shape							, (self.batch_size, self.expected_seq_len, self.hidden_size)						)




			def   lowerCamelCase__  (					self    :       Tuple							, _snake_case    :       Tuple							, _snake_case    :       Optional[Any]							, _snake_case    :       Any						)   ->			Optional[int]:







								"""simple docstring"""
								A_								=    YolosForObjectDetection(_snake_case						)
								model.to(_snake_case						)
								model.eval()

								A_								=    model(pixel_values=_snake_case						)
								A_								=    model(_snake_case						)

								self.parent.assertEqual(result.logits.shape							, (self.batch_size, self.num_detection_tokens, self.num_labels + 1)						)
								self.parent.assertEqual(result.pred_boxes.shape							, (self.batch_size, self.num_detection_tokens, 4)						)

								A_								=    model(pixel_values=_snake_case							, labels=_snake_case						)

								self.parent.assertEqual(result.loss.shape							, ()						)
								self.parent.assertEqual(result.logits.shape							, (self.batch_size, self.num_detection_tokens, self.num_labels + 1)						)
								self.parent.assertEqual(result.pred_boxes.shape							, (self.batch_size, self.num_detection_tokens, 4)						)






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







								"""simple docstring"""
								A_								=    self.prepare_config_and_inputs()
								A_			,     A_			,     A_								=    config_and_inputs
								A_								=    {"pixel_values": pixel_values}
								return config, inputs_dict





@require_torch
class __lowerCAmelCase					(       _lowercase  ,					_lowercase  ,					unittest.TestCase   ):




			"""simple docstring"""







			snake_case						   =					(YolosModel, YolosForObjectDetection) if is_torch_available() else ()
			snake_case						   =					(
			    {"feature-extraction": YolosModel, "object-detection": YolosForObjectDetection} if is_torch_available() else {}
			)

			snake_case						   =					False
			snake_case						   =					False
			snake_case						   =					False
			snake_case						   =					False




			def   lowerCamelCase__  (					self    :       int							, _snake_case    :       Optional[int]							, _snake_case    :       Any							, _snake_case    :       Dict=False						)   ->			List[Any]:







								"""simple docstring"""
								A_								=    super()._prepare_for_class(_snake_case							, _snake_case							, return_labels=_snake_case						)

								if return_labels:
													if model_class.__name__ == "YolosForObjectDetection":
																		A_								=    []
																		for i in range(self.model_tester.batch_size						):
																							A_								=    {}
																							A_								=    torch.ones(
																							    size=(self.model_tester.n_targets,)							, device=_snake_case							, dtype=torch.long						)
																							A_								=    torch.ones(
																							    self.model_tester.n_targets							, 4							, device=_snake_case							, dtype=torch.float						)
																							labels.append(_snake_case						)
																		A_								=    labels

								return inputs_dict




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







								"""simple docstring"""
								A_								=    YolosModelTester(self						)
								A_								=    ConfigTester(self							, config_class=_snake_case							, has_text_modality=_snake_case							, hidden_size=37						)




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







								"""simple docstring"""
								self.config_tester.run_common_tests()




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







								"""simple docstring"""
								# YOLOS does not use inputs_embeds
								pass




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







								"""simple docstring"""
								A_			,     A_								=    self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
													A_								=    model_class(_snake_case						)
													self.assertIsInstance(model.get_input_embeddings()							, (nn.Module)						)
													A_								=    model.get_output_embeddings()
													self.assertTrue(x is None or isinstance(_snake_case							, nn.Linear						)						)




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







								"""simple docstring"""
								A_			,     A_								=    self.model_tester.prepare_config_and_inputs_for_common()

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

													A_								=    ["pixel_values"]
													self.assertListEqual(arg_names[:1]							, _snake_case						)




			def   lowerCamelCase__  (					self    :       List[str]						)   ->			Tuple:







								"""simple docstring"""
								A_								=    self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_snake_case						)




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







								"""simple docstring"""
								A_			,     A_								=    self.model_tester.prepare_config_and_inputs_for_common()
								A_								=    True

								# in YOLOS, the seq_len is different
								A_								=    self.model_tester.expected_seq_len
								for model_class in self.all_model_classes:
													A_								=    True
													A_								=    False
													A_								=    True
													A_								=    model_class(_snake_case						)
													model.to(_snake_case						)
													model.eval()
													with torch.no_grad():
																		A_								=    model(**self._prepare_for_class(_snake_case							, _snake_case						)						)
													A_								=    outputs.attentions
													self.assertEqual(len(_snake_case						)							, self.model_tester.num_hidden_layers						)

													# check that output_attentions also work using config
													del inputs_dict["output_attentions"]
													A_								=    True
													A_								=    model_class(_snake_case						)
													model.to(_snake_case						)
													model.eval()
													with torch.no_grad():
																		A_								=    model(**self._prepare_for_class(_snake_case							, _snake_case						)						)
													A_								=    outputs.attentions
													self.assertEqual(len(_snake_case						)							, self.model_tester.num_hidden_layers						)

													self.assertListEqual(
													    list(attentions[0].shape[-3:]						)							, [self.model_tester.num_attention_heads, seq_len, seq_len]							, )
													A_								=    len(_snake_case						)

													# Check attention is always last and order is fine
													A_								=    True
													A_								=    True
													A_								=    model_class(_snake_case						)
													model.to(_snake_case						)
													model.eval()
													with torch.no_grad():
																		A_								=    model(**self._prepare_for_class(_snake_case							, _snake_case						)						)

													A_								=    1
													self.assertEqual(out_len + added_hidden_states							, len(_snake_case						)						)

													A_								=    outputs.attentions

													self.assertEqual(len(_snake_case						)							, self.model_tester.num_hidden_layers						)
													self.assertListEqual(
													    list(self_attentions[0].shape[-3:]						)							, [self.model_tester.num_attention_heads, seq_len, seq_len]							, )




			def   lowerCamelCase__  (					self    :       Any						)   ->			List[Any]:







								"""simple docstring"""
								def check_hidden_states_output(_snake_case    :       str							, _snake_case    :       Dict							, _snake_case    :       Dict						):
													A_								=    model_class(_snake_case						)
													model.to(_snake_case						)
													model.eval()

													with torch.no_grad():
																		A_								=    model(**self._prepare_for_class(_snake_case							, _snake_case						)						)

													A_								=    outputs.hidden_states

													A_								=    getattr(
													    self.model_tester							, "expected_num_hidden_layers"							, self.model_tester.num_hidden_layers + 1						)
													self.assertEqual(len(_snake_case						)							, _snake_case						)

													# YOLOS has a different seq_length
													A_								=    self.model_tester.expected_seq_len

													self.assertListEqual(
													    list(hidden_states[0].shape[-2:]						)							, [seq_length, self.model_tester.hidden_size]							, )

								A_			,     A_								=    self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
													A_								=    True
													check_hidden_states_output(_snake_case							, _snake_case							, _snake_case						)

													# check that output_hidden_states also work using config
													del inputs_dict["output_hidden_states"]
													A_								=    True

													check_hidden_states_output(_snake_case							, _snake_case							, _snake_case						)




			def   lowerCamelCase__  (					self    :       Dict						)   ->			Any:







								"""simple docstring"""
								A_								=    self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_object_detection(*_snake_case						)






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







								"""simple docstring"""
								for model_name in YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													A_								=    YolosModel.from_pretrained(_snake_case						)
													self.assertIsNotNone(_snake_case						)





def 				A_  ():

					'''simple docstring'''





					A_								=    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"					)
					return image




@require_torch
@require_vision
class __lowerCAmelCase					(       unittest.TestCase   ):




			"""simple docstring"""







			@cached_property
			def   lowerCamelCase__  (					self    :       str						)   ->			Any:







								"""simple docstring"""
								return AutoImageProcessor.from_pretrained("hustvl/yolos-small"						) if is_vision_available() else None






			@slow
			def   lowerCamelCase__  (					self    :       str						)   ->			Union[str, Any]:







								"""simple docstring"""
								A_								=    YolosForObjectDetection.from_pretrained("hustvl/yolos-small"						).to(_snake_case						)

								A_								=    self.default_image_processor
								A_								=    prepare_img()
								A_								=    image_processor(images=_snake_case							, return_tensors="pt"						).to(_snake_case						)

								# forward pass
								with torch.no_grad():
													A_								=    model(inputs.pixel_values						)

								# verify outputs
								A_								=    torch.Size((1, 100, 92)						)
								self.assertEqual(outputs.logits.shape							, _snake_case						)

								A_								=    torch.tensor(
								    [[-2_4.0_2_4_8, -1_0.3_0_2_4, -1_4.8_2_9_0], [-4_2.0_3_9_2, -1_6.8_2_0_0, -2_7.4_3_3_4], [-2_7.2_7_4_3, -1_1.8_1_5_4, -1_8.7_1_4_8]]							, device=_snake_case							, )
								A_								=    torch.tensor(
								    [[0.2_5_5_9, 0.5_4_5_5, 0.4_7_0_6], [0.2_9_8_9, 0.7_2_7_9, 0.1_8_7_5], [0.7_7_3_2, 0.4_0_1_7, 0.4_4_6_2]]							, device=_snake_case						)
								self.assertTrue(torch.allclose(outputs.logits[0, :3, :3]							, _snake_case							, atol=1e-4						)						)
								self.assertTrue(torch.allclose(outputs.pred_boxes[0, :3, :3]							, _snake_case							, atol=1e-4						)						)

								# verify postprocessing
								A_								=    image_processor.post_process_object_detection(
								    _snake_case							, threshold=0.3							, target_sizes=[image.size[::-1]]						)[0]
								A_								=    torch.tensor([0.9_9_9_4, 0.9_7_9_0, 0.9_9_6_4, 0.9_9_7_2, 0.9_8_6_1]						).to(_snake_case						)
								A_								=    [75, 75, 17, 63, 17]
								A_								=    torch.tensor([3_3_5.0_6_0_9, 7_9.3_8_4_8, 3_7_5.4_2_1_6, 1_8_7.2_4_9_5]						).to(_snake_case						)

								self.assertEqual(len(results["scores"]						)							, 5						)
								self.assertTrue(torch.allclose(results["scores"]							, _snake_case							, atol=1e-4						)						)
								self.assertSequenceEqual(results["labels"].tolist()							, _snake_case						)
								self.assertTrue(torch.allclose(results["boxes"][0, :]							, _snake_case						)						)




