




"""simple docstring"""


import os
from shutil import copyfile
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import AddedToken, BatchEncoding, PreTrainedTokenizer
from ...utils import logging


A_      			=       logging.get_logger(__name__)

A_      			=       '''▁'''

A_      			=       {'''vocab_file''': '''sentencepiece.bpe.model'''}

A_      			=       {
    '''vocab_file''': {
        '''facebook/mbart-large-en-ro''': (
            '''https://huggingface.co/facebook/mbart-large-en-ro/resolve/main/sentencepiece.bpe.model'''
        ),
        '''facebook/mbart-large-cc25''': (
            '''https://huggingface.co/facebook/mbart-large-cc25/resolve/main/sentencepiece.bpe.model'''
        ),
    }
}

A_      			=       {
    '''facebook/mbart-large-en-ro''': 10_24,
    '''facebook/mbart-large-cc25''': 10_24,
}

# fmt: off
A_      			=       ['''ar_AR''', '''cs_CZ''', '''de_DE''', '''en_XX''', '''es_XX''', '''et_EE''', '''fi_FI''', '''fr_XX''', '''gu_IN''', '''hi_IN''', '''it_IT''', '''ja_XX''', '''kk_KZ''', '''ko_KR''', '''lt_LT''', '''lv_LV''', '''my_MM''', '''ne_NP''', '''nl_XX''', '''ro_RO''', '''ru_RU''', '''si_LK''', '''tr_TR''', '''vi_VN''', '''zh_CN''']






class       lowercase(  __a				):







 '''simple docstring'''





 lowercase__				      =      VOCAB_FILES_NAMES
 lowercase__				      =      PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 lowercase__				      =      PRETRAINED_VOCAB_FILES_MAP
 lowercase__				      =      ["input_ids", "attention_mask"]

 lowercase__				      =      []
 lowercase__				      =      []


 def __init__(       self:	Optional[int],   a_:	List[Any],   a_:	int="<s>",   a_:	str="</s>",   a_:	Tuple="</s>",   a_:	Union[str, Any]="<s>",   a_:	Union[str, Any]="<unk>",   a_:	Optional[Any]="<pad>",   a_:	List[Any]="<mask>",   a_:	Optional[int]=None,   a_:	str=None,   a_:	Optional[Any]=None,   a_:	Optional[Dict[str, Any]] = None,   a_:	Union[str, Any]=None,   **a_:	Optional[int],   ):




   '''simple docstring'''



   _snake_case							:	List[Any]			=						AddedToken(a_,   lstrip=a_,   rstrip=a_	) if isinstance(a_,   a_	) else mask_token

   _snake_case							:	Tuple			=						{} if sp_model_kwargs is None else sp_model_kwargs

   super().__init__(
       bos_token=a_,   eos_token=a_,   unk_token=a_,   sep_token=a_,   cls_token=a_,   pad_token=a_,   mask_token=a_,   tokenizer_file=a_,   src_lang=a_,   tgt_lang=a_,   additional_special_tokens=a_,   sp_model_kwargs=self.sp_model_kwargs,   **a_,   )

   _snake_case							:	str			=						spm.SentencePieceProcessor(**self.sp_model_kwargs	)
   self.sp_model.Load(str(a_	)	)
   _snake_case							:	List[Any]			=						vocab_file

   # Original fairseq vocab and spm vocab must be "aligned":
   # Vocab    |    0    |    1    |   2    |    3    |  4  |  5  |  6  |   7   |   8   |  9
   # -------- | ------- | ------- | ------ | ------- | --- | --- | --- | ----- | ----- | ----
   # fairseq  | '<s>'   | '<pad>' | '</s>' | '<unk>' | ',' | '.' | '▁' | 's'   | '▁de' | '-'
   # spm      | '<unk>' | '<s>'   | '</s>' | ','     | '.' | '▁' | 's' | '▁de' | '-'   | '▁a'

   # Mimic fairseq token-to-id alignment for the first 4 token
   _snake_case							:	List[Any]			=						{"""<s>""": 0, """<pad>""": 1, """</s>""": 2, """<unk>""": 3}

   # The first "real" token "," has position 4 in the original fairseq vocab and position 3 in the spm vocab
   _snake_case							:	List[Any]			=						1

   _snake_case							:	List[str]			=						len(self.sp_model	)
   _snake_case							:	Tuple			=						{
       code: self.sp_model_size + i + self.fairseq_offset for i, code in enumerate(a_	)
   }
   _snake_case							:	Any			=						{v: k for k, v in self.lang_code_to_id.items()}
   _snake_case							:	Any			=						len(self.sp_model	) + len(self.lang_code_to_id	) + self.fairseq_offset

   self.fairseq_tokens_to_ids.update(self.lang_code_to_id	)
   _snake_case							:	int			=						{v: k for k, v in self.fairseq_tokens_to_ids.items()}
   _snake_case							:	Optional[int]			=						list(self.lang_code_to_id.keys()	)

   if additional_special_tokens is not None:
     # Only add those special tokens if they are not already there.
     self._additional_special_tokens.extend(
         [t for t in additional_special_tokens if t not in self._additional_special_tokens]	)

   _snake_case							:	Union[str, Any]			=						src_lang if src_lang is not None else """en_XX"""
   _snake_case							:	Dict			=						self.lang_code_to_id[self._src_lang]
   _snake_case							:	Optional[Any]			=						tgt_lang
   self.set_src_lang_special_tokens(self._src_lang	)


 def __getstate__(       self:	List[str]	):




   '''simple docstring'''



   _snake_case							:	Optional[Any]			=						self.__dict__.copy()
   _snake_case							:	str			=						None
   _snake_case							:	Any			=						self.sp_model.serialized_model_proto()
   return state


 def __setstate__(       self:	List[Any],   a_:	Optional[int]	):




   '''simple docstring'''



   _snake_case							:	int			=						d

   # for backward compatibility
   if not hasattr(self,   """sp_model_kwargs"""	):
     _snake_case							:	Union[str, Any]			=						{}

   _snake_case							:	Optional[Any]			=						spm.SentencePieceProcessor(**self.sp_model_kwargs	)
   self.sp_model.LoadFromSerializedProto(self.sp_model_proto	)


 @property
 def 				UpperCamelCase_     (       self:	Any	):




   '''simple docstring'''



   return len(self.sp_model	) + len(self.lang_code_to_id	) + self.fairseq_offset + 1  # Plus 1 for the mask token


 @property
 def 				UpperCamelCase_     (       self:	List[Any]	):




   '''simple docstring'''



   return self._src_lang


 @src_lang.setter
 def 				UpperCamelCase_     (       self:	List[Any],   a_:	str	):




   '''simple docstring'''



   _snake_case							:	Optional[int]			=						new_src_lang
   self.set_src_lang_special_tokens(self._src_lang	)


 def 				UpperCamelCase_     (       self:	Any,   a_:	List[int],   a_:	Optional[List[int]] = None,   a_:	bool = False	):




   '''simple docstring'''



   if already_has_special_tokens:
     return super().get_special_tokens_mask(
         token_ids_a=a_,   token_ids_a=a_,   already_has_special_tokens=a_	)

   _snake_case							:	str			=						[1] * len(self.prefix_tokens	)
   _snake_case							:	List[str]			=						[1] * len(self.suffix_tokens	)
   if token_ids_a is None:
     return prefix_ones + ([0] * len(a_	)) + suffix_ones
   return prefix_ones + ([0] * len(a_	)) + ([0] * len(a_	)) + suffix_ones


 def 				UpperCamelCase_     (       self:	Dict,   a_:	List[int],   a_:	Optional[List[int]] = None	):




   '''simple docstring'''



   if token_ids_a is None:
     return self.prefix_tokens + token_ids_a + self.suffix_tokens
   # We don't expect to process pairs, but leave the pair logic for API consistency
   return self.prefix_tokens + token_ids_a + token_ids_a + self.suffix_tokens


 def 				UpperCamelCase_     (       self:	List[str],   a_:	List[int],   a_:	Optional[List[int]] = None	):




   '''simple docstring'''



   _snake_case							:	str			=						[self.sep_token_id]
   _snake_case							:	str			=						[self.cls_token_id]

   if token_ids_a is None:
     return len(cls + token_ids_a + sep	) * [0]
   return len(cls + token_ids_a + sep + sep + token_ids_a + sep	) * [0]


 def 				UpperCamelCase_     (       self:	Optional[Any],   a_:	Optional[int],   a_:	str,   a_:	Optional[str],   a_:	Optional[str],   **a_:	Any	):




   '''simple docstring'''



   if src_lang is None or tgt_lang is None:
     raise ValueError("""Translation requires a `src_lang` and a `tgt_lang` for this model"""	)
   _snake_case							:	List[Any]			=						src_lang
   _snake_case							:	Dict			=						self(a_,   add_special_tokens=a_,   return_tensors=a_,   **a_	)
   _snake_case							:	Dict			=						self.convert_tokens_to_ids(a_	)
   _snake_case							:	Optional[Any]			=						tgt_lang_id
   return inputs


 def 				UpperCamelCase_     (       self:	Optional[int]	):




   '''simple docstring'''



   _snake_case							:	Optional[Any]			=						{self.convert_ids_to_tokens(a_	): i for i in range(self.vocab_size	)}
   vocab.update(self.added_tokens_encoder	)
   return vocab


 def 				UpperCamelCase_     (       self:	List[Any],   a_:	str	):




   '''simple docstring'''



   return self.sp_model.encode(a_,   out_type=a_	)


 def 				UpperCamelCase_     (       self:	Optional[int],   a_:	List[Any]	):




   '''simple docstring'''



   if token in self.fairseq_tokens_to_ids:
     return self.fairseq_tokens_to_ids[token]
   _snake_case							:	Any			=						self.sp_model.PieceToId(a_	)

   # Need to return unknown token if the SP model returned 0
   return spm_id + self.fairseq_offset if spm_id else self.unk_token_id


 def 				UpperCamelCase_     (       self:	Optional[int],   a_:	List[Any]	):




   '''simple docstring'''



   if index in self.fairseq_ids_to_tokens:
     return self.fairseq_ids_to_tokens[index]
   return self.sp_model.IdToPiece(index - self.fairseq_offset	)


 def 				UpperCamelCase_     (       self:	List[str],   a_:	Union[str, Any]	):




   '''simple docstring'''



   _snake_case							:	Optional[int]			=						"""""".join(a_	).replace(a_,   """ """	).strip()
   return out_string


 def 				UpperCamelCase_     (       self:	Dict,   a_:	str,   a_:	Optional[str] = None	):




   '''simple docstring'''



   if not os.path.isdir(a_	):
     logger.error(f"Vocabulary path ({save_directory}) should be a directory"	)
     return
   _snake_case							:	List[str]			=						os.path.join(
       a_,   (filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]	)

   if os.path.abspath(self.vocab_file	) != os.path.abspath(a_	) and os.path.isfile(self.vocab_file	):
     copyfile(self.vocab_file,   a_	)
   elif not os.path.isfile(self.vocab_file	):
     with open(a_,   """wb"""	) as fi:
       _snake_case							:	str			=						self.sp_model.serialized_model_proto()
       fi.write(a_	)

   return (out_vocab_file,)


 def 				UpperCamelCase_     (       self:	Optional[Any],   a_:	List[str],   a_:	str = "en_XX",   a_:	Optional[List[str]] = None,   a_:	str = "ro_RO",   **a_:	Dict,   ):




   '''simple docstring'''



   _snake_case							:	Optional[Any]			=						src_lang
   _snake_case							:	int			=						tgt_lang
   return super().prepare_seqaseq_batch(a_,   a_,   **a_	)


 def 				UpperCamelCase_     (       self:	Optional[Any]	):




   '''simple docstring'''



   return self.set_src_lang_special_tokens(self.src_lang	)


 def 				UpperCamelCase_     (       self:	Tuple	):




   '''simple docstring'''



   return self.set_tgt_lang_special_tokens(self.tgt_lang	)


 def 				UpperCamelCase_     (       self:	Optional[Any],   a_:	Any	):




   '''simple docstring'''



   _snake_case							:	List[Any]			=						self.lang_code_to_id[src_lang]
   _snake_case							:	Dict			=						[]
   _snake_case							:	List[str]			=						[self.eos_token_id, self.cur_lang_code]


 def 				UpperCamelCase_     (       self:	Tuple,   a_:	str	):




   '''simple docstring'''



   _snake_case							:	Tuple			=						self.lang_code_to_id[lang]
   _snake_case							:	str			=						[]
   _snake_case							:	Union[str, Any]			=						[self.eos_token_id, self.cur_lang_code]








"""simple docstring"""


import inspect
import unittest

from datasets import load_dataset
from packaging import version

from transformers import BeitConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_multi_gpu, 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, _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 (
         MODEL_MAPPING,
         BeitForImageClassification,
         BeitForMaskedImageModeling,
         BeitForSemanticSegmentation,
         BeitModel,
     )
     from transformers.models.beit.modeling_beit import BEIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
     import PIL
     from PIL import Image

     from transformers import BeitImageProcessor






class       lowercase:







 '''simple docstring'''





 def __init__(       self:	Optional[Any],   a_:	Union[str, Any],   a_:	int=100,   a_:	int=13,   a_:	List[Any]=30,   a_:	str=2,   a_:	Optional[Any]=3,   a_:	Optional[int]=True,   a_:	Any=True,   a_:	Optional[Any]=32,   a_:	Tuple=4,   a_:	str=4,   a_:	List[Any]=37,   a_:	List[str]="gelu",   a_:	str=0.1,   a_:	Optional[int]=0.1,   a_:	Any=10,   a_:	List[str]=0.02,   a_:	Dict=3,   a_:	str=None,   a_:	Optional[int]=[0, 1, 2, 3],   ):




   '''simple docstring'''



   _snake_case							:	Optional[int]			=						parent
   _snake_case							:	Optional[Any]			=						100
   _snake_case							:	Any			=						batch_size
   _snake_case							:	List[Any]			=						image_size
   _snake_case							:	Optional[Any]			=						patch_size
   _snake_case							:	str			=						num_channels
   _snake_case							:	Tuple			=						is_training
   _snake_case							:	Tuple			=						use_labels
   _snake_case							:	Any			=						hidden_size
   _snake_case							:	Optional[int]			=						num_hidden_layers
   _snake_case							:	List[str]			=						num_attention_heads
   _snake_case							:	Union[str, Any]			=						intermediate_size
   _snake_case							:	Dict			=						hidden_act
   _snake_case							:	str			=						hidden_dropout_prob
   _snake_case							:	Optional[int]			=						attention_probs_dropout_prob
   _snake_case							:	Optional[Any]			=						type_sequence_label_size
   _snake_case							:	Any			=						initializer_range
   _snake_case							:	List[str]			=						scope
   _snake_case							:	int			=						out_indices
   _snake_case							:	Optional[Any]			=						num_labels

   # in BeiT, the seq length equals the number of patches + 1 (we add 1 for the [CLS] token)
   _snake_case							:	Dict			=						(image_size // patch_size) ** 2
   _snake_case							:	str			=						num_patches + 1


 def 				UpperCamelCase_     (       self:	Any	):




   '''simple docstring'''



   _snake_case							:	int			=						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

   _snake_case							:	List[Any]			=						None
   _snake_case							:	Tuple			=						None
   if self.use_labels:
     _snake_case							:	str			=						ids_tensor([self.batch_size],   self.type_sequence_label_size	)
     _snake_case							:	List[str]			=						ids_tensor([self.batch_size, self.image_size, self.image_size],   self.num_labels	)

   _snake_case							:	List[str]			=						self.get_config()

   return config, pixel_values, labels, pixel_labels


 def 				UpperCamelCase_     (       self:	List[Any]	):




   '''simple docstring'''



   return BeitConfig(
       vocab_size=self.vocab_size,   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=a_,   initializer_range=self.initializer_range,   out_indices=self.out_indices,   )


 def 				UpperCamelCase_     (       self:	List[Any],   a_:	List[Any],   a_:	Any,   a_:	Optional[Any],   a_:	List[str]	):




   '''simple docstring'''



   _snake_case							:	str			=						BeitModel(config=a_	)
   model.to(a_	)
   model.eval()
   _snake_case							:	Dict			=						model(a_	)
   self.parent.assertEqual(result.last_hidden_state.shape,   (self.batch_size, self.seq_length, self.hidden_size)	)


 def 				UpperCamelCase_     (       self:	str,   a_:	List[Any],   a_:	Optional[Any],   a_:	Optional[int],   a_:	List[Any]	):




   '''simple docstring'''



   _snake_case							:	List[str]			=						BeitForMaskedImageModeling(config=a_	)
   model.to(a_	)
   model.eval()
   _snake_case							:	Union[str, Any]			=						model(a_	)
   self.parent.assertEqual(result.logits.shape,   (self.batch_size, self.seq_length - 1, self.vocab_size)	)


 def 				UpperCamelCase_     (       self:	Any,   a_:	List[str],   a_:	Any,   a_:	List[Any],   a_:	Optional[Any]	):




   '''simple docstring'''



   _snake_case							:	Any			=						self.type_sequence_label_size
   _snake_case							:	Any			=						BeitForImageClassification(a_	)
   model.to(a_	)
   model.eval()
   _snake_case							:	List[Any]			=						model(a_,   labels=a_	)
   self.parent.assertEqual(result.logits.shape,   (self.batch_size, self.type_sequence_label_size)	)

   # test greyscale images
   _snake_case							:	Any			=						1
   _snake_case							:	str			=						BeitForImageClassification(a_	)
   model.to(a_	)
   model.eval()

   _snake_case							:	Dict			=						floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
   _snake_case							:	Optional[Any]			=						model(a_,   labels=a_	)
   self.parent.assertEqual(result.logits.shape,   (self.batch_size, self.type_sequence_label_size)	)


 def 				UpperCamelCase_     (       self:	List[Any],   a_:	Optional[int],   a_:	List[Any],   a_:	str,   a_:	int	):




   '''simple docstring'''



   _snake_case							:	List[str]			=						self.num_labels
   _snake_case							:	List[Any]			=						BeitForSemanticSegmentation(a_	)
   model.to(a_	)
   model.eval()
   _snake_case							:	List[str]			=						model(a_	)
   self.parent.assertEqual(
       result.logits.shape,   (self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)	)
   _snake_case							:	str			=						model(a_,   labels=a_	)
   self.parent.assertEqual(
       result.logits.shape,   (self.batch_size, self.num_labels, self.image_size * 2, self.image_size * 2)	)


 def 				UpperCamelCase_     (       self:	List[str]	):




   '''simple docstring'''



   _snake_case							:	Tuple			=						self.prepare_config_and_inputs()
   _snake_case	,      _snake_case	,      _snake_case	,      _snake_case							:	Any			=						config_and_inputs
   _snake_case							:	Optional[int]			=						{"""pixel_values""": pixel_values}
   return config, inputs_dict







@require_torch
class       lowercase(  __a ,    __a ,    unittest.TestCase				):







 '''simple docstring'''





 lowercase__				      =      (
     (BeitModel, BeitForImageClassification, BeitForMaskedImageModeling, BeitForSemanticSegmentation)
     if is_torch_available()
     else ()
 )
 lowercase__				      =      (
     {
         "feature-extraction": BeitModel,
         "image-classification": BeitForImageClassification,
         "image-segmentation": BeitForSemanticSegmentation,
     }
     if is_torch_available()
     else {}
 )

 lowercase__				      =      False
 lowercase__				      =      False
 lowercase__				      =      False


 def 				UpperCamelCase_     (       self:	Union[str, Any]	):




   '''simple docstring'''



   _snake_case							:	Dict			=						BeitModelTester(self	)
   _snake_case							:	int			=						ConfigTester(self,   config_class=a_,   has_text_modality=a_,   hidden_size=37	)


 def 				UpperCamelCase_     (       self:	str	):




   '''simple docstring'''



   self.config_tester.run_common_tests()


 @unittest.skip(reason="""BEiT does not use inputs_embeds"""	)
 def 				UpperCamelCase_     (       self:	Optional[int]	):




   '''simple docstring'''



   pass


 @require_torch_multi_gpu
 @unittest.skip(reason="""BEiT has some layers using `add_module` which doesn't work well with `nn.DataParallel`"""	)
 def 				UpperCamelCase_     (       self:	str	):




   '''simple docstring'''



   pass


 def 				UpperCamelCase_     (       self:	List[Any]	):




   '''simple docstring'''



   _snake_case	,      _snake_case							:	Any			=						self.model_tester.prepare_config_and_inputs_for_common()

   for model_class in self.all_model_classes:
     _snake_case							:	List[str]			=						model_class(a_	)
     self.assertIsInstance(model.get_input_embeddings(),   (nn.Module)	)
     _snake_case							:	Tuple			=						model.get_output_embeddings()
     self.assertTrue(x is None or isinstance(a_,   nn.Linear	)	)


 def 				UpperCamelCase_     (       self:	Optional[Any]	):




   '''simple docstring'''



   _snake_case	,      _snake_case							:	Optional[Any]			=						self.model_tester.prepare_config_and_inputs_for_common()

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

     _snake_case							:	List[Any]			=						["""pixel_values"""]
     self.assertListEqual(arg_names[:1],   a_	)


 def 				UpperCamelCase_     (       self:	List[str]	):




   '''simple docstring'''



   _snake_case							:	Optional[int]			=						self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*a_	)


 def 				UpperCamelCase_     (       self:	int	):




   '''simple docstring'''



   _snake_case							:	Optional[Any]			=						self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_masked_lm(*a_	)


 def 				UpperCamelCase_     (       self:	Dict	):




   '''simple docstring'''



   _snake_case							:	Dict			=						self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_image_classification(*a_	)


 def 				UpperCamelCase_     (       self:	Optional[int]	):




   '''simple docstring'''



   _snake_case							:	List[Any]			=						self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_for_semantic_segmentation(*a_	)


 def 				UpperCamelCase_     (       self:	int	):




   '''simple docstring'''



   if not self.model_tester.is_training:
     return

   _snake_case	,      _snake_case							:	List[str]			=						self.model_tester.prepare_config_and_inputs_for_common()
   _snake_case							:	Any			=						True

   for model_class in self.all_model_classes:
     # we don't test BeitForMaskedImageModeling
     if model_class in [*get_values(a_	), BeitForMaskedImageModeling]:
       continue

     _snake_case							:	List[Any]			=						model_class(a_	)
     model.to(a_	)
     model.train()
     _snake_case							:	Dict			=						self._prepare_for_class(a_,   a_,   return_labels=a_	)
     _snake_case							:	List[Any]			=						model(**a_	).loss
     loss.backward()


 def 				UpperCamelCase_     (       self:	Any	):




   '''simple docstring'''



   _snake_case	,      _snake_case							:	List[Any]			=						self.model_tester.prepare_config_and_inputs_for_common()
   if not self.model_tester.is_training:
     return

   _snake_case							:	Dict			=						False
   _snake_case							:	Optional[Any]			=						True

   for model_class in self.all_model_classes:
     # we don't test BeitForMaskedImageModeling
     if (
         model_class in [*get_values(a_	), BeitForMaskedImageModeling]
         or not model_class.supports_gradient_checkpointing
     ):
       continue

     _snake_case							:	Any			=						model_class(a_	)
     model.gradient_checkpointing_enable()
     model.to(a_	)
     model.train()
     _snake_case							:	Any			=						self._prepare_for_class(a_,   a_,   return_labels=a_	)
     _snake_case							:	int			=						model(**a_	).loss
     loss.backward()


 def 				UpperCamelCase_     (       self:	Tuple	):




   '''simple docstring'''



   _snake_case	,      _snake_case							:	List[str]			=						self.model_tester.prepare_config_and_inputs_for_common()

   _snake_case							:	int			=						_config_zero_init(a_	)
   for model_class in self.all_model_classes:
     _snake_case							:	Tuple			=						model_class(config=a_	)
     for name, param in model.named_parameters():
       # we skip lambda parameters as these require special initial values
       # determined by config.layer_scale_init_value
       if "lambda" in name:
         continue
       if 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",   )


 @slow
 def 				UpperCamelCase_     (       self:	int	):




   '''simple docstring'''



   for model_name in BEIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
     _snake_case							:	Optional[int]			=						BeitModel.from_pretrained(a_	)
     self.assertIsNotNone(a_	)







def       UpperCAmelCase__ ():
  """simple docstring"""

  _snake_case							:	Union[str, Any]			=						Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""					)
  return image






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







 '''simple docstring'''





 @cached_property
 def 				UpperCamelCase_     (       self:	Dict	):




   '''simple docstring'''



   return BeitImageProcessor.from_pretrained("""microsoft/beit-base-patch16-224"""	) if is_vision_available() else None


 @slow
 def 				UpperCamelCase_     (       self:	Union[str, Any]	):




   '''simple docstring'''



   _snake_case							:	str			=						BeitForMaskedImageModeling.from_pretrained("""microsoft/beit-base-patch16-224-pt22k"""	).to(a_	)

   _snake_case							:	Dict			=						self.default_image_processor
   _snake_case							:	Dict			=						prepare_img()
   _snake_case							:	List[str]			=						image_processor(images=a_,   return_tensors="""pt"""	).pixel_values.to(a_	)

   # prepare bool_masked_pos
   _snake_case							:	Optional[int]			=						torch.ones((1, 196),   dtype=torch.bool	).to(a_	)

   # forward pass
   with torch.no_grad():
     _snake_case							:	int			=						model(pixel_values=a_,   bool_masked_pos=a_	)
   _snake_case							:	Dict			=						outputs.logits

   # verify the logits
   _snake_case							:	Optional[int]			=						torch.Size((1, 196, 8_192)	)
   self.assertEqual(logits.shape,   a_	)

   _snake_case							:	Optional[Any]			=						torch.tensor(
       [[-3.2_437, 0.5_072, -13.9_174], [-3.2_456, 0.4_948, -13.9_401], [-3.2_033, 0.5_121, -13.8_550]]	).to(a_	)

   self.assertTrue(torch.allclose(logits[bool_masked_pos][:3, :3],   a_,   atol=1E-2	)	)


 @slow
 def 				UpperCamelCase_     (       self:	Optional[int]	):




   '''simple docstring'''



   _snake_case							:	Dict			=						BeitForImageClassification.from_pretrained("""microsoft/beit-base-patch16-224"""	).to(a_	)

   _snake_case							:	List[Any]			=						self.default_image_processor
   _snake_case							:	Any			=						prepare_img()
   _snake_case							:	Any			=						image_processor(images=a_,   return_tensors="""pt"""	).to(a_	)

   # forward pass
   with torch.no_grad():
     _snake_case							:	int			=						model(**a_	)
   _snake_case							:	Optional[int]			=						outputs.logits

   # verify the logits
   _snake_case							:	Tuple			=						torch.Size((1, 1_000)	)
   self.assertEqual(logits.shape,   a_	)

   _snake_case							:	Any			=						torch.tensor([-1.2_385, -1.0_987, -1.0_108]	).to(a_	)

   self.assertTrue(torch.allclose(logits[0, :3],   a_,   atol=1E-4	)	)

   _snake_case							:	str			=						281
   self.assertEqual(logits.argmax(-1	).item(),   a_	)


 @slow
 def 				UpperCamelCase_     (       self:	Dict	):




   '''simple docstring'''



   _snake_case							:	int			=						BeitForImageClassification.from_pretrained("""microsoft/beit-large-patch16-224-pt22k-ft22k"""	).to(
       a_	)

   _snake_case							:	int			=						self.default_image_processor
   _snake_case							:	Optional[Any]			=						prepare_img()
   _snake_case							:	Union[str, Any]			=						image_processor(images=a_,   return_tensors="""pt"""	).to(a_	)

   # forward pass
   with torch.no_grad():
     _snake_case							:	Union[str, Any]			=						model(**a_	)
   _snake_case							:	Dict			=						outputs.logits

   # verify the logits
   _snake_case							:	Tuple			=						torch.Size((1, 21_841)	)
   self.assertEqual(logits.shape,   a_	)

   _snake_case							:	Optional[int]			=						torch.tensor([1.6_881, -0.2_787, 0.5_901]	).to(a_	)

   self.assertTrue(torch.allclose(logits[0, :3],   a_,   atol=1E-4	)	)

   _snake_case							:	List[str]			=						2_396
   self.assertEqual(logits.argmax(-1	).item(),   a_	)


 @slow
 def 				UpperCamelCase_     (       self:	Dict	):




   '''simple docstring'''



   _snake_case							:	List[str]			=						BeitForSemanticSegmentation.from_pretrained("""microsoft/beit-base-finetuned-ade-640-640"""	)
   _snake_case							:	int			=						model.to(a_	)

   _snake_case							:	List[str]			=						BeitImageProcessor(do_resize=a_,   size=640,   do_center_crop=a_	)

   _snake_case							:	Optional[int]			=						load_dataset("""hf-internal-testing/fixtures_ade20k""",   split="""test"""	)
   _snake_case							:	Union[str, Any]			=						Image.open(ds[0]["""file"""]	)
   _snake_case							:	List[Any]			=						image_processor(images=a_,   return_tensors="""pt"""	).to(a_	)

   # forward pass
   with torch.no_grad():
     _snake_case							:	Optional[int]			=						model(**a_	)
   _snake_case							:	Union[str, Any]			=						outputs.logits

   # verify the logits
   _snake_case							:	List[str]			=						torch.Size((1, 150, 160, 160)	)
   self.assertEqual(logits.shape,   a_	)

   _snake_case							:	Optional[int]			=						version.parse(PIL.__version__	) < version.parse("""9.0.0"""	)

   if is_pillow_less_than_a:
     _snake_case							:	Any			=						torch.tensor(
         [
             [[-4.9_225, -2.3_954, -3.0_522], [-2.8_822, -1.0_046, -1.7_561], [-2.9_549, -1.3_228, -2.1_347]],
             [[-5.8_168, -3.4_129, -4.0_778], [-3.8_651, -2.2_214, -3.0_277], [-3.8_356, -2.4_643, -3.3_535]],
             [[-0.0_078, 3.9_952, 4.0_754], [2.9_856, 4.6_944, 5.0_035], [3.2_413, 4.7_813, 4.9_969]],
         ],   device=a_,   )
   else:
     _snake_case							:	Optional[Any]			=						torch.tensor(
         [
             [[-4.8_960, -2.3_688, -3.0_355], [-2.8_478, -0.9_836, -1.7_418], [-2.9_449, -1.3_332, -2.1_456]],
             [[-5.8_081, -3.4_124, -4.1_006], [-3.8_561, -2.2_081, -3.0_323], [-3.8_365, -2.4_601, -3.3_669]],
             [[-0.0_309, 3.9_868, 4.0_540], [2.9_640, 4.6_877, 4.9_976], [3.2_081, 4.7_690, 4.9_942]],
         ],   device=a_,   )

   self.assertTrue(torch.allclose(logits[0, :3, :3, :3],   a_,   atol=1E-4	)	)


 @slow
 def 				UpperCamelCase_     (       self:	Optional[Any]	):




   '''simple docstring'''



   _snake_case							:	int			=						BeitForSemanticSegmentation.from_pretrained("""microsoft/beit-base-finetuned-ade-640-640"""	)
   _snake_case							:	List[Any]			=						model.to(a_	)

   _snake_case							:	Tuple			=						BeitImageProcessor(do_resize=a_,   size=640,   do_center_crop=a_	)

   _snake_case							:	Union[str, Any]			=						load_dataset("""hf-internal-testing/fixtures_ade20k""",   split="""test"""	)
   _snake_case							:	str			=						Image.open(ds[0]["""file"""]	)
   _snake_case							:	Tuple			=						image_processor(images=a_,   return_tensors="""pt"""	).to(a_	)

   # forward pass
   with torch.no_grad():
     _snake_case							:	Optional[int]			=						model(**a_	)

   _snake_case							:	Union[str, Any]			=						outputs.logits.detach().cpu()

   _snake_case							:	Union[str, Any]			=						image_processor.post_process_semantic_segmentation(outputs=a_,   target_sizes=[(500, 300)]	)
   _snake_case							:	Optional[int]			=						torch.Size((500, 300)	)
   self.assertEqual(segmentation[0].shape,   a_	)

   _snake_case							:	List[str]			=						image_processor.post_process_semantic_segmentation(outputs=a_	)
   _snake_case							:	List[str]			=						torch.Size((160, 160)	)
   self.assertEqual(segmentation[0].shape,   a_	)


