


'''simple docstring'''
from typing import Optional, Tuple

import jax
import jax.numpy as jnp
from flax import linen as nn
from flax.core.frozen_dict import FrozenDict
from transformers import CLIPConfig, FlaxPreTrainedModel
from transformers.models.clip.modeling_flax_clip import FlaxCLIPVisionModule


def 			a      (			__a ,					__a ,					__a=1e-12   )  ->	str:



					'''simple docstring'''






					UpperCamelCase__   :Optional[Any]												= jnp.divide(emb_a.T ,					jnp.clip(jnp.linalg.norm(__a ,					axis=1   ) ,					a_min=__a   )   ).T
					UpperCamelCase__   :Optional[Any]												= jnp.divide(emb_a.T ,					jnp.clip(jnp.linalg.norm(__a ,					axis=1   ) ,					a_min=__a   )   ).T
					return jnp.matmul(__a ,					norm_emb_a.T   )
class    lowercase	(							nn.Module					):

		"""simple docstring"""

		_a     =				42
		_a     =				jnp.floataa




		def     lowerCAmelCase__				(		self							):

							'''simple docstring'''


							UpperCamelCase__   :Optional[int]												= FlaxCLIPVisionModule(self.config.vision_config							)
							UpperCamelCase__   :Tuple												= nn.Dense(self.config.projection_dim    ,   use_bias=UpperCamelCase_    ,   dtype=self.dtype							)

							UpperCamelCase__   :Optional[Any]												= self.param('''concept_embeds'''    ,   jax.nn.initializers.ones    ,   (17, self.config.projection_dim)							)
							UpperCamelCase__   :Optional[Any]												= self.param(
							    '''special_care_embeds'''    ,   jax.nn.initializers.ones    ,   (3, self.config.projection_dim)							)

							UpperCamelCase__   :Tuple												= self.param('''concept_embeds_weights'''    ,   jax.nn.initializers.ones    ,   (17,)							)
							UpperCamelCase__   :List[str]												= self.param('''special_care_embeds_weights'''    ,   jax.nn.initializers.ones    ,   (3,)							)




		def __call__(		self    ,   UpperCamelCase_							):

							'''simple docstring'''


							UpperCamelCase__   :List[str]												= self.vision_model(UpperCamelCase_							)[1]
							UpperCamelCase__   :Optional[int]												= self.visual_projection(UpperCamelCase_							)

							UpperCamelCase__   :List[Any]												= jax_cosine_distance(UpperCamelCase_    ,   self.special_care_embeds							)
							UpperCamelCase__   :List[str]												= jax_cosine_distance(UpperCamelCase_    ,   self.concept_embeds							)

							# increase this value to create a stronger `nfsw` filter
							# at the cost of increasing the possibility of filtering benign image inputs
							UpperCamelCase__   :int												= 0.0

							UpperCamelCase__   :int												= special_cos_dist - self.special_care_embeds_weights[None, :] + adjustment
							UpperCamelCase__   :Optional[int]												= jnp.round(UpperCamelCase_    ,   3							)
							UpperCamelCase__   :Union[str, Any]												= jnp.any(special_scores > 0    ,   axis=1    ,   keepdims=UpperCamelCase_							)
							# Use a lower threshold if an image has any special care concept
							UpperCamelCase__   :Union[str, Any]												= is_special_care * 0.01

							UpperCamelCase__   :List[str]												= cos_dist - self.concept_embeds_weights[None, :] + special_adjustment
							UpperCamelCase__   :Optional[int]												= jnp.round(UpperCamelCase_    ,   3							)
							UpperCamelCase__   :int												= jnp.any(concept_scores > 0    ,   axis=1							)

							return has_nsfw_concepts



class    lowercase	(							A__					):

		"""simple docstring"""

		_a     =				CLIPConfig
		_a     =				'clip_input'
		_a     =				FlaxStableDiffusionSafetyCheckerModule




		def __init__(		self    ,   UpperCamelCase_    ,   UpperCamelCase_ = None    ,   UpperCamelCase_ = 0    ,   UpperCamelCase_ = jnp.floataa    ,   UpperCamelCase_ = True    ,   **UpperCamelCase_    ,   ):

							'''simple docstring'''


							if input_shape is None:
												UpperCamelCase__   :Union[str, Any]												= (1, 224, 224, 3)
							UpperCamelCase__   :Dict												= self.module_class(config=UpperCamelCase_    ,   dtype=UpperCamelCase_    ,   **UpperCamelCase_							)
							super().__init__(UpperCamelCase_    ,   UpperCamelCase_    ,   input_shape=UpperCamelCase_    ,   seed=UpperCamelCase_    ,   dtype=UpperCamelCase_    ,   _do_init=_do_init							)




		def     lowerCAmelCase__				(		self    ,   UpperCamelCase_    ,   UpperCamelCase_    ,   UpperCamelCase_ = None							):

							'''simple docstring'''


							UpperCamelCase__   :Dict												= jax.random.normal(UpperCamelCase_    ,   UpperCamelCase_							)

							UpperCamelCase__					,				UpperCamelCase__   :List[Any]												= jax.random.split(UpperCamelCase_							)
							UpperCamelCase__   :Tuple												= {'''params''': params_rng, '''dropout''': dropout_rng}

							UpperCamelCase__   :List[str]												= self.module.init(UpperCamelCase_    ,   UpperCamelCase_							)['''params''']

							return random_params




		def __call__(		self    ,   UpperCamelCase_    ,   UpperCamelCase_ = None    ,   ):

							'''simple docstring'''


							UpperCamelCase__   :Any												= jnp.transpose(UpperCamelCase_    ,   (0, 2, 3, 1)							)

							return self.module.apply(
							    {'''params''': params or self.params}    ,   jnp.array(UpperCamelCase_    ,   dtype=jnp.floataa							)    ,   rngs={}    ,   )



import os
import tempfile
import unittest

from transformers import DistilBertConfig, is_torch_available
from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
	import torch

	from transformers import (
	    DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
	    DistilBertForMaskedLM,
	    DistilBertForMultipleChoice,
	    DistilBertForQuestionAnswering,
	    DistilBertForSequenceClassification,
	    DistilBertForTokenClassification,
	    DistilBertModel,
	)





class       A    (   A_ ):


							def __init__(self      ,				lowerCAmelCase      ,				lowerCAmelCase=1_3      ,				lowerCAmelCase=7      ,				lowerCAmelCase=True      ,				lowerCAmelCase=True      ,				lowerCAmelCase=False      ,				lowerCAmelCase=True      ,				lowerCAmelCase=9_9      ,				lowerCAmelCase=3_2      ,				lowerCAmelCase=5      ,				lowerCAmelCase=4      ,				lowerCAmelCase=3_7      ,				lowerCAmelCase="gelu"      ,				lowerCAmelCase=0.1      ,				lowerCAmelCase=0.1      ,				lowerCAmelCase=5_1_2      ,				lowerCAmelCase=1_6      ,				lowerCAmelCase=2      ,				lowerCAmelCase=0.02      ,				lowerCAmelCase=3      ,				lowerCAmelCase=4      ,				lowerCAmelCase=None      ,				):
									__lowercase=			parent
									__lowercase=			batch_size
									__lowercase=			seq_length
									__lowercase=			is_training
									__lowercase=			use_input_mask
									__lowercase=			use_token_type_ids
									__lowercase=			use_labels
									__lowercase=			vocab_size
									__lowercase=			hidden_size
									__lowercase=			num_hidden_layers
									__lowercase=			num_attention_heads
									__lowercase=			intermediate_size
									__lowercase=			hidden_act
									__lowercase=			hidden_dropout_prob
									__lowercase=			attention_probs_dropout_prob
									__lowercase=			max_position_embeddings
									__lowercase=			type_vocab_size
									__lowercase=			type_sequence_label_size
									__lowercase=			initializer_range
									__lowercase=			num_labels
									__lowercase=			num_choices
									__lowercase=			scope


							def 			_A       (self					):
									__lowercase=			ids_tensor([self.batch_size, self.seq_length]      ,				self.vocab_size					)

									__lowercase=			None
									if self.use_input_mask:
											__lowercase=			random_attention_mask([self.batch_size, self.seq_length]					)

									__lowercase=			None
									__lowercase=			None
									__lowercase=			None
									if self.use_labels:
											__lowercase=			ids_tensor([self.batch_size]      ,				self.type_sequence_label_size					)
											__lowercase=			ids_tensor([self.batch_size, self.seq_length]      ,				self.num_labels					)
											__lowercase=			ids_tensor([self.batch_size]      ,				self.num_choices					)

									__lowercase=			self.get_config()

									return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels


							def 			_A       (self					):
									return DistilBertConfig(
									    vocab_size=self.vocab_size      ,				dim=self.hidden_size      ,				n_layers=self.num_hidden_layers      ,				n_heads=self.num_attention_heads      ,				hidden_dim=self.intermediate_size      ,				hidden_act=self.hidden_act      ,				dropout=self.hidden_dropout_prob      ,				attention_dropout=self.attention_probs_dropout_prob      ,				max_position_embeddings=self.max_position_embeddings      ,				initializer_range=self.initializer_range      ,				)


							def 			_A       (self      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase					):
									__lowercase=			DistilBertModel(config=lowerCAmelCase					)
									model.to(lowerCAmelCase					)
									model.eval()
									__lowercase=			model(lowerCAmelCase      ,				lowerCAmelCase					)
									__lowercase=			model(lowerCAmelCase					)
									self.parent.assertEqual(result.last_hidden_state.shape      ,				(self.batch_size, self.seq_length, self.hidden_size)					)


							def 			_A       (self      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase					):
									__lowercase=			DistilBertForMaskedLM(config=lowerCAmelCase					)
									model.to(lowerCAmelCase					)
									model.eval()
									__lowercase=			model(lowerCAmelCase      ,				attention_mask=lowerCAmelCase      ,				labels=lowerCAmelCase					)
									self.parent.assertEqual(result.logits.shape      ,				(self.batch_size, self.seq_length, self.vocab_size)					)


							def 			_A       (self      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase					):
									__lowercase=			DistilBertForQuestionAnswering(config=lowerCAmelCase					)
									model.to(lowerCAmelCase					)
									model.eval()
									__lowercase=			model(
									    lowerCAmelCase      ,				attention_mask=lowerCAmelCase      ,				start_positions=lowerCAmelCase      ,				end_positions=lowerCAmelCase					)
									self.parent.assertEqual(result.start_logits.shape      ,				(self.batch_size, self.seq_length)					)
									self.parent.assertEqual(result.end_logits.shape      ,				(self.batch_size, self.seq_length)					)


							def 			_A       (self      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase					):
									__lowercase=			self.num_labels
									__lowercase=			DistilBertForSequenceClassification(lowerCAmelCase					)
									model.to(lowerCAmelCase					)
									model.eval()
									__lowercase=			model(lowerCAmelCase      ,				attention_mask=lowerCAmelCase      ,				labels=lowerCAmelCase					)
									self.parent.assertEqual(result.logits.shape      ,				(self.batch_size, self.num_labels)					)


							def 			_A       (self      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase					):
									__lowercase=			self.num_labels
									__lowercase=			DistilBertForTokenClassification(config=lowerCAmelCase					)
									model.to(lowerCAmelCase					)
									model.eval()

									__lowercase=			model(lowerCAmelCase      ,				attention_mask=lowerCAmelCase      ,				labels=lowerCAmelCase					)
									self.parent.assertEqual(result.logits.shape      ,				(self.batch_size, self.seq_length, self.num_labels)					)


							def 			_A       (self      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase      ,				lowerCAmelCase					):
									__lowercase=			self.num_choices
									__lowercase=			DistilBertForMultipleChoice(config=lowerCAmelCase					)
									model.to(lowerCAmelCase					)
									model.eval()
									__lowercase=			input_ids.unsqueeze(1					).expand(-1      ,				self.num_choices      ,				-1					).contiguous()
									__lowercase=			input_mask.unsqueeze(1					).expand(-1      ,				self.num_choices      ,				-1					).contiguous()
									__lowercase=			model(
									    lowerCAmelCase      ,				attention_mask=lowerCAmelCase      ,				labels=lowerCAmelCase      ,				)
									self.parent.assertEqual(result.logits.shape      ,				(self.batch_size, self.num_choices)					)







							def 			_A       (self					):
									__lowercase=			self.prepare_config_and_inputs()
									((__lowercase),							(__lowercase),							(__lowercase),							(__lowercase),							(__lowercase),							(__lowercase))=			config_and_inputs
									__lowercase=			{'input_ids': input_ids, 'attention_mask': input_mask}
									return config, inputs_dict





@require_torch
class       A    (   A_					,				A_					,				unittest.TestCase ):
							UpperCamelCase_   :							Any       =(
							    (
							        DistilBertModel,
							        DistilBertForMaskedLM,
							        DistilBertForMultipleChoice,
							        DistilBertForQuestionAnswering,
							        DistilBertForSequenceClassification,
							        DistilBertForTokenClassification,
							    )
							    if is_torch_available()
							    else None
							)
							UpperCamelCase_   :							Optional[int]       =(
							    {
							        '''feature-extraction''': DistilBertModel,
							        '''fill-mask''': DistilBertForMaskedLM,
							        '''question-answering''': DistilBertForQuestionAnswering,
							        '''text-classification''': DistilBertForSequenceClassification,
							        '''token-classification''': DistilBertForTokenClassification,
							        '''zero-shot''': DistilBertForSequenceClassification,
							    }
							    if is_torch_available()
							    else {}
							)
							UpperCamelCase_   :							str       =True
							UpperCamelCase_   :							str       =True
							UpperCamelCase_   :							Union[str, Any]       =True
							UpperCamelCase_   :							Optional[int]       =True


							def 			_A       (self					):
									__lowercase=			DistilBertModelTester(self					)
									__lowercase=			ConfigTester(self      ,				config_class=lowerCAmelCase      ,				dim=3_7					)


							def 			_A       (self					):
									self.config_tester.run_common_tests()


							def 			_A       (self					):
									__lowercase=			self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_model(*lowerCAmelCase					)


							def 			_A       (self					):
									__lowercase=			self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_for_masked_lm(*lowerCAmelCase					)


							def 			_A       (self					):
									__lowercase=			self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_for_question_answering(*lowerCAmelCase					)


							def 			_A       (self					):
									__lowercase=			self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_for_sequence_classification(*lowerCAmelCase					)


							def 			_A       (self					):
									__lowercase=			self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_for_token_classification(*lowerCAmelCase					)


							def 			_A       (self					):
									__lowercase=			self.model_tester.prepare_config_and_inputs()
									self.model_tester.create_and_check_distilbert_for_multiple_choice(*lowerCAmelCase					)


							@slow
							def 			_A       (self					):
									for model_name in DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__lowercase=			DistilBertModel.from_pretrained(lowerCAmelCase					)
											self.assertIsNotNone(lowerCAmelCase					)







							@slow
							@require_torch_gpu
							def 			_A       (self					):
									__lowercase,							__lowercase=			self.model_tester.prepare_config_and_inputs_for_common()
									for model_class in self.all_model_classes:
											# BertForMultipleChoice behaves incorrectly in JIT environments.
											if model_class == DistilBertForMultipleChoice:
													return

											__lowercase=			True
											__lowercase=			model_class(config=lowerCAmelCase					)

											__lowercase=			self._prepare_for_class(lowerCAmelCase      ,				lowerCAmelCase					)
											__lowercase=			torch.jit.trace(
											    lowerCAmelCase      ,				(inputs_dict['input_ids'].to('cpu'					), inputs_dict['attention_mask'].to('cpu'					))					)

											with tempfile.TemporaryDirectory() as tmp:
													torch.jit.save(lowerCAmelCase      ,				os.path.join(lowerCAmelCase      ,				'traced_model.pt'					)					)
													__lowercase=			torch.jit.load(os.path.join(lowerCAmelCase      ,				'traced_model.pt'					)      ,				map_location=lowerCAmelCase					)
													loaded(inputs_dict['input_ids'].to(lowerCAmelCase					)      ,				inputs_dict['attention_mask'].to(lowerCAmelCase					)					)





@require_torch
class       A    (   unittest.TestCase ):


							@slow
							def 			_A       (self					):
									__lowercase=			DistilBertModel.from_pretrained('distilbert-base-uncased'					)
									__lowercase=			torch.tensor([[0, 3_4_5, 2_3_2, 3_2_8, 7_4_0, 1_4_0, 1_6_9_5, 6_9, 6_0_7_8, 1_5_8_8, 2]]					)
									__lowercase=			torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]					)
									with torch.no_grad():
											__lowercase=			model(lowerCAmelCase      ,				attention_mask=lowerCAmelCase					)[0]
									__lowercase=			torch.Size((1, 1_1, 7_6_8)					)
									self.assertEqual(output.shape      ,				lowerCAmelCase					)
									__lowercase=			torch.tensor(
									    [[[-0.16_39, 0.32_99, 0.16_48], [-0.17_46, 0.32_89, 0.17_10], [-0.18_84, 0.33_57, 0.18_10]]]					)

									self.assertTrue(torch.allclose(output[:, 1:4, 1:4]      ,				lowerCAmelCase      ,				atol=1E-4					)					)






