



class    _lowerCAmelCase    :





		"""simple docstring"""






		def __init__(					self							,    _lowercase = ""							,    _lowercase = False   ) ->						None:







								'''simple docstring'''

								snake_case_   : dict[str, RadixNode]						=			{}

								# A node will be a leaf if the tree contains its word
								snake_case_   : int						=			is_leaf

								snake_case_   : Union[str, Any]						=			prefix





		def    UpperCAmelCase__							(					self							,    _lowercase   ) ->						tuple[str, str, str]:







								'''simple docstring'''

								snake_case_   : Optional[int]						=			0
								for q, w in zip(self.prefix							,    _lowercase   ):
														if q != w:
																				break

														x += 1

								return self.prefix[:x], self.prefix[x:], word[x:]





		def    UpperCAmelCase__							(					self							,    _lowercase   ) ->						None:







								'''simple docstring'''

								for word in words:
														self.insert(_lowercase   )





		def    UpperCAmelCase__							(					self							,    _lowercase   ) ->						None:







								'''simple docstring'''

								if self.prefix == word:
														snake_case_   : Dict						=			True

								# Case 2: The node has no edges that have a prefix to the word
								# Solution: We create an edge from the current node to a new one
								# containing the word
								elif word[0] not in self.nodes:
														snake_case_   : Optional[int]						=			RadixNode(prefix=_lowercase							,    is_leaf=_lowercase   )

								else:
														snake_case_   : List[Any]						=			self.nodes[word[0]]
														snake_case_   : Any						=			incoming_node.match(
														    _lowercase   )

														# Case 3: The node prefix is equal to the matching
														# Solution: We insert remaining word on the next node
														if remaining_prefix == "":
																				self.nodes[matching_string[0]].insert(_lowercase   )

														# Case 4: The word is greater equal to the matching
														# Solution: Create a node in between both nodes, change
														# prefixes and add the new node for the remaining word
														else:
																				snake_case_   : Any						=			remaining_prefix

																				snake_case_   : int						=			self.nodes[matching_string[0]]
																				snake_case_   : int						=			RadixNode(_lowercase							,    _lowercase   )
																				snake_case_   : List[Any]						=			aux_node

																				if remaining_word == "":
																										snake_case_   : Optional[Any]						=			True
																				else:
																										self.nodes[matching_string[0]].insert(_lowercase   )





		def    UpperCAmelCase__							(					self							,    _lowercase   ) ->						bool:







								'''simple docstring'''

								snake_case_   : List[str]						=			self.nodes.get(word[0]							,    _lowercase   )
								if not incoming_node:
														return False
								else:
														snake_case_   : Optional[int]						=			incoming_node.match(
														    _lowercase   )
														# If there is remaining prefix, the word can't be on the tree
														if remaining_prefix != "":
																				return False
														# This applies when the word and the prefix are equal
														elif remaining_word == "":
																				return incoming_node.is_leaf
														# We have word remaining so we check the next node
														else:
																				return incoming_node.find(_lowercase   )





		def    UpperCAmelCase__							(					self							,    _lowercase   ) ->						bool:







								'''simple docstring'''

								snake_case_   : List[str]						=			self.nodes.get(word[0]							,    _lowercase   )
								if not incoming_node:
														return False
								else:
														snake_case_   : Optional[int]						=			incoming_node.match(
														    _lowercase   )
														# If there is remaining prefix, the word can't be on the tree
														if remaining_prefix != "":
																				return False
														# We have word remaining so we check the next node
														elif remaining_word != "":
																				return incoming_node.delete(_lowercase   )
														else:
																				# If it is not a leaf, we don't have to delete
																				if not incoming_node.is_leaf:
																										return False
																				else:
																										# We delete the nodes if no edges go from it
																										if len(incoming_node.nodes   ) == 0:
																																del self.nodes[word[0]]
																																# We merge the current node with its only child
																																if len(self.nodes   ) == 1 and not self.is_leaf:
																																						snake_case_   : List[str]						=			list(self.nodes.values()   )[0]
																																						snake_case_   : Dict						=			merging_node.is_leaf
																																						self.prefix += merging_node.prefix
																																						snake_case_   : List[Any]						=			merging_node.nodes
                    # If there is more than 1 edge, we just mark it as non-leaf
																										elif len(incoming_node.nodes   ) > 1:
																																snake_case_   : int						=			False
																										# If there is 1 edge, we merge it with its child
																										else:
																																snake_case_   : Tuple						=			list(incoming_node.nodes.values()   )[0]
																																snake_case_   : Optional[int]						=			merging_node.is_leaf
																																incoming_node.prefix += merging_node.prefix
																																snake_case_   : Union[str, Any]						=			merging_node.nodes

																										return True





		def    UpperCAmelCase__							(					self							,    _lowercase = 0   ) ->						None:







								'''simple docstring'''

								if self.prefix != "":
														print("""-""" * height							,    self.prefix							,    """  (leaf)""" if self.is_leaf else """"""   )

								for value in self.nodes.values():
														value.print_tree(height + 1   )




def 	__lowerCAmelCase						(		):


						'''simple docstring'''






						snake_case_   : int						=			"""banana bananas bandana band apple all beast""".split()
						snake_case_   : List[str]						=			RadixNode()
						root.insert_many(__UpperCamelCase    )

						assert all(root.find(__UpperCamelCase    ) for word in words    )
						assert not root.find("""bandanas"""    )
						assert not root.find("""apps"""    )
						root.delete("""all"""    )
						assert not root.find("""all"""    )
						root.delete("""banana"""    )
						assert not root.find("""banana"""    )
						assert root.find("""bananas"""    )

						return True
def 	__lowerCAmelCase						(		):


						'''simple docstring'''






						assert test_trie()
def 	__lowerCAmelCase						(		):


						'''simple docstring'''






						snake_case_   : Union[str, Any]						=			RadixNode()
						snake_case_   : Any						=			"""banana bananas bandanas bandana band apple all beast""".split()
						root.insert_many(__UpperCamelCase    )

						print("""Words:"""					, __UpperCamelCase    )
						print("""Tree:"""    )
						root.print_tree()


if __name__ == "__main__":
					main()






"""simple docstring"""





import torch
import torch.nn as nn
from transformers import CLIPConfig, CLIPVisionModel, PreTrainedModel

from ...utils import logging


__lowerCAmelCase       :					Optional[int]      					=					logging.get_logger(__name__)
def 	__lowerCAmelCase						(		__UpperCamelCase      :			Tuple					, __UpperCamelCase      :			Optional[Any]    ):


						'''simple docstring'''






						snake_case_   : Union[str, Any]						=			nn.functional.normalize(__UpperCamelCase    )
						snake_case_   : Tuple						=			nn.functional.normalize(__UpperCamelCase    )
						return torch.mm(__UpperCamelCase					, normalized_text_embeds.t()    )






class    _lowerCAmelCase    (				SCREAMING_SNAKE_CASE__		):





		"""simple docstring"""






		_lowerCamelCase			  =       CLIPConfig

		_lowerCamelCase			  =       ['''CLIPEncoderLayer''']





		def __init__(					self							,    _lowercase   ) ->						Union[str, Any]:







								'''simple docstring'''

								super().__init__(_lowercase   )

								snake_case_   : Tuple						=			CLIPVisionModel(config.vision_config   )
								snake_case_   : int						=			nn.Linear(config.vision_config.hidden_size							,    config.projection_dim							,    bias=_lowercase   )

								snake_case_   : Optional[Any]						=			nn.Parameter(torch.ones(1_7							,    config.projection_dim   )							,    requires_grad=_lowercase   )
								snake_case_   : Dict						=			nn.Parameter(torch.ones(3							,    config.projection_dim   )							,    requires_grad=_lowercase   )

								snake_case_   : Any						=			nn.Parameter(torch.ones(1_7   )							,    requires_grad=_lowercase   )
								snake_case_   : List[str]						=			nn.Parameter(torch.ones(3   )							,    requires_grad=_lowercase   )





		@torch.no_grad()
		def    UpperCAmelCase__							(					self							,    _lowercase							,    _lowercase   ) ->						Any:







								'''simple docstring'''

								snake_case_   : int						=			self.vision_model(_lowercase   )[1]  # pooled_output
								snake_case_   : str						=			self.visual_projection(_lowercase   )

								# we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
								snake_case_   : Dict						=			cosine_distance(_lowercase							,    self.special_care_embeds   ).cpu().float().numpy()
								snake_case_   : List[str]						=			cosine_distance(_lowercase							,    self.concept_embeds   ).cpu().float().numpy()

								snake_case_   : Any						=			[]
								snake_case_   : Any						=			image_embeds.shape[0]
								for i in range(_lowercase   ):
														snake_case_   : List[Any]						=			{"""special_scores""": {}, """special_care""": [], """concept_scores""": {}, """bad_concepts""": []}

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

														for concept_idx in range(len(special_cos_dist[0]   )   ):
																				snake_case_   : List[str]						=			special_cos_dist[i][concept_idx]
																				snake_case_   : Union[str, Any]						=			self.special_care_embeds_weights[concept_idx].item()
																				snake_case_   : Tuple						=			round(concept_cos - concept_threshold + adjustment							,    3   )
																				if result_img["special_scores"][concept_idx] > 0:
																										result_img["special_care"].append({concept_idx, result_img["""special_scores"""][concept_idx]}   )
																										snake_case_   : Dict						=			0.01

														for concept_idx in range(len(cos_dist[0]   )   ):
																				snake_case_   : int						=			cos_dist[i][concept_idx]
																				snake_case_   : List[Any]						=			self.concept_embeds_weights[concept_idx].item()
																				snake_case_   : List[str]						=			round(concept_cos - concept_threshold + adjustment							,    3   )
																				if result_img["concept_scores"][concept_idx] > 0:
																										result_img["bad_concepts"].append(_lowercase   )

														result.append(_lowercase   )

								snake_case_   : Union[str, Any]						=			[len(res["""bad_concepts"""]   ) > 0 for res in result]

								return images, has_nsfw_concepts





		@torch.no_grad()
		def    UpperCAmelCase__							(					self							,    _lowercase							,    _lowercase   ) ->						Tuple:







								'''simple docstring'''

								snake_case_   : Optional[Any]						=			self.vision_model(_lowercase   )[1]  # pooled_output
								snake_case_   : List[str]						=			self.visual_projection(_lowercase   )

								snake_case_   : str						=			cosine_distance(_lowercase							,    self.special_care_embeds   )
								snake_case_   : Optional[int]						=			cosine_distance(_lowercase							,    self.concept_embeds   )

								# increase this value to create a stronger `nsfw` filter
								# at the cost of increasing the possibility of filtering benign images
								snake_case_   : Tuple						=			0.0

								snake_case_   : List[Any]						=			special_cos_dist - self.special_care_embeds_weights + adjustment
								# special_scores = special_scores.round(decimals=3)
								snake_case_   : str						=			torch.any(special_scores > 0							,    dim=1   )
								snake_case_   : List[str]						=			special_care * 0.01
								snake_case_   : Optional[int]						=			special_adjustment.unsqueeze(1   ).expand(-1							,    cos_dist.shape[1]   )

								snake_case_   : Optional[Any]						=			(cos_dist - self.concept_embeds_weights) + special_adjustment
								# concept_scores = concept_scores.round(decimals=3)
								snake_case_   : str						=			torch.any(concept_scores > 0							,    dim=1   )

								return images, has_nsfw_concepts

