





from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowercase      :       List[Any]									=  logging.get_logger(__name__)

lowercase      :       List[str]									=  {
    """google/switch-base-8""": """https://huggingface.co/google/switch-base-8/blob/main/config.json""",
}





class  A__    (							__UpperCAmelCase	):




   """simple docstring"""



   __A   :				int         =  "switch_transformers"
   __A   :				int         =  ["past_key_values"]
   __A   :				Dict         =  {"hidden_size": "d_model", "num_attention_heads": "num_heads", "num_hidden_layers": "num_layers"}

   def __init__(					self					,  lowercase=3_2128					,  lowercase=768					,  lowercase=64					,  lowercase=2048					,  lowercase=64					,  lowercase=12					,  lowercase=3					,  lowercase=12					,  lowercase=3					,  lowercase=12					,  lowercase=8					,  lowercase=False					,  lowercase=0.01					,  lowercase="float32"					,  lowercase=False					,  lowercase=32					,  lowercase=128					,  lowercase=0.1					,  lowercase=1e-6					,  lowercase=0.0_01					,  lowercase=0.0_01					,  lowercase=1.0					,  lowercase="relu"					,  lowercase=True					,  lowercase=False					,  lowercase=True					,  lowercase=0					,  lowercase=1					,  **lowercase					,  )			->						Optional[int]:







          '''simple docstring'''

          a__						:	str =				vocab_size
          a__						:	Any =				d_model
          a__						:	int =				d_kv
          a__						:	Union[str, Any] =				d_ff

          a__						:	str =				num_sparse_encoder_layers

          a__						:	List[str] =				num_layers
          a__						:	str =				(
              num_decoder_layers if num_decoder_layers is not None else self.num_layers
          )  # default = symmetry
          a__						:	Tuple =				num_sparse_decoder_layers

          # This tells us, each how many encoder layer we'll have to set a sparse layer.
          if self.num_sparse_encoder_layers > 0:
                 a__						:	List[str] =				self.num_layers // self.num_sparse_encoder_layers
          else:
                 a__						:	Union[str, Any] =				self.num_layers  # HACK: this will create 0 sparse layers

          # This tells us, each how many encoder layer we'll have to set a sparse layer.
          if self.num_sparse_decoder_layers > 0:
                 a__						:	Any =				self.num_decoder_layers // self.num_sparse_decoder_layers
          else:
                 a__						:	Tuple =				self.num_decoder_layers  # HACK: this will create 0 sparse layers

          a__						:	Any =				num_heads
          a__						:	List[Any] =				num_experts
          a__						:	str =				expert_capacity
          a__						:	List[Any] =				router_bias
          a__						:	int =				router_jitter_noise
          if router_dtype not in ["float32", "float16", "bfloat16"]:
                 raise ValueError(F'`router_dtype` must be one of \'float32\', \'float16\' or \'bfloat16\', got {router_dtype}')
          a__						:	Tuple =				router_dtype

          a__						:	int =				router_ignore_padding_tokens
          a__						:	Union[str, Any] =				relative_attention_num_buckets
          a__						:	int =				relative_attention_max_distance

          a__						:	Tuple =				dropout_rate
          a__						:	List[str] =				layer_norm_epsilon
          a__						:	List[Any] =				initializer_factor
          a__						:	List[Any] =				feed_forward_proj
          a__						:	Optional[int] =				use_cache
          a__						:	int =				add_router_probs

          a__						:	List[Any] =				router_z_loss_coef
          a__						:	Union[str, Any] =				router_aux_loss_coef

          a__						:	Optional[int] =				self.feed_forward_proj.split('-')
          a__						:	Tuple =				act_info[-1]
          a__						:	Union[str, Any] =				act_info[0] == "gated"

          if len(__A) > 1 and act_info[0] != "gated" or len(__A) > 2:
                 raise ValueError(
                     F'`feed_forward_proj`: {feed_forward_proj} is not a valid activation function of the dense layer.'
                     'Please make sure `feed_forward_proj` is of the format `gated-{ACT_FN}` or `{ACT_FN}`, e.g. '
                     '\'gated-gelu\' or \'relu\'')

          # for backwards compatibility
          if feed_forward_proj == "gated-gelu":
                 a__						:	Any =				"gelu_new"

          super().__init__(
              pad_token_id=__A					,  eos_token_id=__A					,  is_encoder_decoder=__A					,  **__A					,  )






import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
   from PIL import Image

   from transformers import OwlViTImageProcessor, OwlViTProcessor
@require_vision
class 	UpperCAmelCase_					(					unittest.TestCase    ):

   '''simple docstring'''




   def _snake_case    (		self ):






     """simple docstring"""





     lowerCamelCase :					str    =				tempfile.mkdtemp()

     # fmt: off
     lowerCamelCase :					Any    =				["", "l", "o", "w", "e", "r", "s", "t", "i", "d", "n", "lo", "l</w>", "w</w>", "r</w>", "t</w>", "low</w>", "er</w>", "lowest</w>", "newer</w>", "wider", "<unk>", "<|startoftext|>", "<|endoftext|>"]
     # fmt: on
     lowerCamelCase :					List[Any]    =				dict(zip(__A						,				range(len(__A ) ) ) )
     lowerCamelCase :					List[Any]    =				["#version: 0.2", "l o", "lo w</w>", "e r</w>", ""]
     lowerCamelCase :					Optional[Any]    =				{"unk_token": "<unk>"}

     lowerCamelCase :					int    =				os.path.join(self.tmpdirname						,				VOCAB_FILES_NAMES["vocab_file"] )
     lowerCamelCase :					List[Any]    =				os.path.join(self.tmpdirname						,				VOCAB_FILES_NAMES["merges_file"] )
     with open(self.vocab_file						,				"w"						,				encoding="utf-8" ) as fp:
       fp.write(json.dumps(__A ) + "\n" )
     with open(self.merges_file						,				"w"						,				encoding="utf-8" ) as fp:
       fp.write("\n".join(__A ) )

     lowerCamelCase :					str    =				{
         "do_resize": True,
         "size": 20,
         "do_center_crop": True,
         "crop_size": 18,
         "do_normalize": True,
         "image_mean": [0.48145466, 0.4578275, 0.40821073],
         "image_std": [0.26862954, 0.26130258, 0.27577711],
     }
     lowerCamelCase :					str    =				os.path.join(self.tmpdirname						,				__A )
     with open(self.image_processor_file						,				"w"						,				encoding="utf-8" ) as fp:
       json.dump(__A						,				__A )






   def _snake_case    (		self						,				**__A ):






     """simple docstring"""





     return CLIPTokenizer.from_pretrained(self.tmpdirname						,				pad_token="!"						,				**__A )






   def _snake_case    (		self						,				**__A ):






     """simple docstring"""





     return CLIPTokenizerFast.from_pretrained(self.tmpdirname						,				pad_token="!"						,				**__A )






   def _snake_case    (		self						,				**__A ):






     """simple docstring"""





     return OwlViTImageProcessor.from_pretrained(self.tmpdirname						,				**__A )






   def _snake_case    (		self ):






     """simple docstring"""





     shutil.rmtree(self.tmpdirname )






   def _snake_case    (		self ):






     """simple docstring"""





     lowerCamelCase :					Dict    =				[np.random.randint(255						,				size=(3, 30, 400)						,				dtype=np.uinta )]

     lowerCamelCase :					Tuple    =				[Image.fromarray(np.moveaxis(__A						,				0						,				-1 ) ) for x in image_inputs]

     return image_inputs






   def _snake_case    (		self ):






     """simple docstring"""





     lowerCamelCase :					List[Any]    =				self.get_tokenizer()
     lowerCamelCase :					Optional[Any]    =				self.get_rust_tokenizer()
     lowerCamelCase :					Tuple    =				self.get_image_processor()

     lowerCamelCase :					List[Any]    =				OwlViTProcessor(tokenizer=__A						,				image_processor=__A )
     processor_slow.save_pretrained(self.tmpdirname )
     lowerCamelCase :					Optional[Any]    =				OwlViTProcessor.from_pretrained(self.tmpdirname						,				use_fast=__A )

     lowerCamelCase :					Optional[int]    =				OwlViTProcessor(tokenizer=__A						,				image_processor=__A )
     processor_fast.save_pretrained(self.tmpdirname )
     lowerCamelCase :					Tuple    =				OwlViTProcessor.from_pretrained(self.tmpdirname )

     self.assertEqual(processor_slow.tokenizer.get_vocab()						,				tokenizer_slow.get_vocab() )
     self.assertEqual(processor_fast.tokenizer.get_vocab()						,				tokenizer_fast.get_vocab() )
     self.assertEqual(tokenizer_slow.get_vocab()						,				tokenizer_fast.get_vocab() )
     self.assertIsInstance(processor_slow.tokenizer						,				__A )
     self.assertIsInstance(processor_fast.tokenizer						,				__A )

     self.assertEqual(processor_slow.image_processor.to_json_string()						,				image_processor.to_json_string() )
     self.assertEqual(processor_fast.image_processor.to_json_string()						,				image_processor.to_json_string() )
     self.assertIsInstance(processor_slow.image_processor						,				__A )
     self.assertIsInstance(processor_fast.image_processor						,				__A )






   def _snake_case    (		self ):






     """simple docstring"""





     lowerCamelCase :					Optional[Any]    =				OwlViTProcessor(tokenizer=self.get_tokenizer()						,				image_processor=self.get_image_processor() )
     processor.save_pretrained(self.tmpdirname )

     lowerCamelCase :					int    =				self.get_tokenizer(bos_token="(BOS)"						,				eos_token="(EOS)" )
     lowerCamelCase :					List[str]    =				self.get_image_processor(do_normalize=__A )

     lowerCamelCase :					Optional[int]    =				OwlViTProcessor.from_pretrained(
         self.tmpdirname						,				bos_token="(BOS)"						,				eos_token="(EOS)"						,				do_normalize=__A )

     self.assertEqual(processor.tokenizer.get_vocab()						,				tokenizer_add_kwargs.get_vocab() )
     self.assertIsInstance(processor.tokenizer						,				__A )

     self.assertEqual(processor.image_processor.to_json_string()						,				image_processor_add_kwargs.to_json_string() )
     self.assertIsInstance(processor.image_processor						,				__A )






   def _snake_case    (		self ):






     """simple docstring"""





     lowerCamelCase :					List[Any]    =				self.get_image_processor()
     lowerCamelCase :					Optional[int]    =				self.get_tokenizer()

     lowerCamelCase :					Dict    =				OwlViTProcessor(tokenizer=__A						,				image_processor=__A )

     lowerCamelCase :					Tuple    =				self.prepare_image_inputs()

     lowerCamelCase :					int    =				image_processor(__A						,				return_tensors="np" )
     lowerCamelCase :					Union[str, Any]    =				processor(images=__A						,				return_tensors="np" )

     for key in input_image_proc.keys():
       self.assertAlmostEqual(input_image_proc[key].sum()						,				input_processor[key].sum()						,				delta=1e-2 )






   def _snake_case    (		self ):






     """simple docstring"""





     lowerCamelCase :					Union[str, Any]    =				self.get_image_processor()
     lowerCamelCase :					Dict    =				self.get_tokenizer()

     lowerCamelCase :					Union[str, Any]    =				OwlViTProcessor(tokenizer=__A						,				image_processor=__A )

     lowerCamelCase :					Tuple    =				"lower newer"

     lowerCamelCase :					Union[str, Any]    =				processor(text=__A						,				return_tensors="np" )

     lowerCamelCase :					List[Any]    =				tokenizer(__A						,				return_tensors="np" )

     for key in encoded_tok.keys():
       self.assertListEqual(encoded_tok[key][0].tolist()						,				encoded_processor[key][0].tolist() )






   def _snake_case    (		self ):






     """simple docstring"""





     lowerCamelCase :					Any    =				self.get_image_processor()
     lowerCamelCase :					Any    =				self.get_tokenizer()

     lowerCamelCase :					int    =				OwlViTProcessor(tokenizer=__A						,				image_processor=__A )

     lowerCamelCase :					Optional[Any]    =				"lower newer"
     lowerCamelCase :					Dict    =				self.prepare_image_inputs()

     lowerCamelCase :					Any    =				processor(text=__A						,				images=__A )

     self.assertListEqual(list(inputs.keys() )						,				["input_ids", "attention_mask", "pixel_values"] )

     # test if it raises when no input is passed
     with pytest.raises(__A ):
       processor()






   def _snake_case    (		self ):






     """simple docstring"""





     lowerCamelCase :					Any    =				"google/owlvit-base-patch32"
     lowerCamelCase :					List[Any]    =				OwlViTProcessor.from_pretrained(__A )

     lowerCamelCase :					Tuple    =				["cat", "nasa badge"]
     lowerCamelCase :					str    =				processor(text=__A )

     lowerCamelCase :					Union[str, Any]    =				16
     self.assertListEqual(list(inputs.keys() )						,				["input_ids", "attention_mask"] )
     self.assertEqual(inputs["input_ids"].shape						,				(2, seq_length) )

     # test if it raises when no input is passed
     with pytest.raises(__A ):
       processor()






   def _snake_case    (		self ):






     """simple docstring"""





     lowerCamelCase :					str    =				"google/owlvit-base-patch32"
     lowerCamelCase :					Optional[int]    =				OwlViTProcessor.from_pretrained(__A )

     lowerCamelCase :					Dict    =				[["cat", "nasa badge"], ["person"]]
     lowerCamelCase :					int    =				processor(text=__A )

     lowerCamelCase :					Tuple    =				16
     lowerCamelCase :					Any    =				len(__A )
     lowerCamelCase :					Optional[Any]    =				max([len(__A ) for texts in input_texts] )

     self.assertListEqual(list(inputs.keys() )						,				["input_ids", "attention_mask"] )
     self.assertEqual(inputs["input_ids"].shape						,				(batch_size * num_max_text_queries, seq_length) )

     # test if it raises when no input is passed
     with pytest.raises(__A ):
       processor()






   def _snake_case    (		self ):






     """simple docstring"""





     lowerCamelCase :					Dict    =				"google/owlvit-base-patch32"
     lowerCamelCase :					Tuple    =				OwlViTProcessor.from_pretrained(__A )

     lowerCamelCase :					List[Any]    =				["cat", "nasa badge"]
     lowerCamelCase :					Optional[Any]    =				processor(text=__A )

     lowerCamelCase :					int    =				16
     lowerCamelCase :					List[str]    =				inputs["input_ids"]
     lowerCamelCase :					int    =				[
         [4_9406, 2368, 4_9407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
         [4_9406, 6841, 1_1301, 4_9407, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
     ]

     self.assertListEqual(list(inputs.keys() )						,				["input_ids", "attention_mask"] )
     self.assertEqual(inputs["input_ids"].shape						,				(2, seq_length) )
     self.assertListEqual(list(input_ids[0] )						,				predicted_ids[0] )
     self.assertListEqual(list(input_ids[1] )						,				predicted_ids[1] )






   def _snake_case    (		self ):






     """simple docstring"""





     lowerCamelCase :					Any    =				self.get_image_processor()
     lowerCamelCase :					List[str]    =				self.get_tokenizer()

     lowerCamelCase :					str    =				OwlViTProcessor(tokenizer=__A						,				image_processor=__A )

     lowerCamelCase :					Dict    =				self.prepare_image_inputs()
     lowerCamelCase :					Union[str, Any]    =				self.prepare_image_inputs()

     lowerCamelCase :					Any    =				processor(images=__A						,				query_images=__A )

     self.assertListEqual(list(inputs.keys() )						,				["query_pixel_values", "pixel_values"] )

     # test if it raises when no input is passed
     with pytest.raises(__A ):
       processor()






   def _snake_case    (		self ):






     """simple docstring"""





     lowerCamelCase :					Optional[Any]    =				self.get_image_processor()
     lowerCamelCase :					Optional[int]    =				self.get_tokenizer()

     lowerCamelCase :					Dict    =				OwlViTProcessor(tokenizer=__A						,				image_processor=__A )

     lowerCamelCase :					Optional[int]    =				[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

     lowerCamelCase :					List[Any]    =				processor.batch_decode(__A )
     lowerCamelCase :					Union[str, Any]    =				tokenizer.batch_decode(__A )

     self.assertListEqual(__A						,				__A )



