



'''simple docstring'''







from __future__ import annotations

from typing import Any







def  SCREAMING_SNAKE_CASE__ (				*SCREAMING_SNAKE_CASE     ):
		if all(_check_not_integer(SCREAMING_SNAKE_CASE     ) for m in matrix_s     ):
				for i in matrix_s[1:]:
						_verify_matrix_sizes(matrix_s[0] ,		SCREAMING_SNAKE_CASE     )
				return [[sum(SCREAMING_SNAKE_CASE     ) for t in zip(*SCREAMING_SNAKE_CASE     )] for m in zip(*SCREAMING_SNAKE_CASE     )]
		raise TypeError('Expected a matrix, got int/list instead'     )







def  SCREAMING_SNAKE_CASE__ (				SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE     ):
		if (
		    _check_not_integer(SCREAMING_SNAKE_CASE     )
		    and _check_not_integer(SCREAMING_SNAKE_CASE     )
		    and _verify_matrix_sizes(SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE     )
		):
				return [[i - j for i, j in zip(*SCREAMING_SNAKE_CASE     )] for m in zip(SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE     )]
		raise TypeError('Expected a matrix, got int/list instead'     )







def  SCREAMING_SNAKE_CASE__ (				SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE     ):
		return [[x * n for x in row] for row in matrix]







def  SCREAMING_SNAKE_CASE__ (				SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE     ):
		if _check_not_integer(SCREAMING_SNAKE_CASE     ) and _check_not_integer(SCREAMING_SNAKE_CASE     ):
				SCREAMING_SNAKE_CASE_						,		SCREAMING_SNAKE_CASE_						:Dict										=      _verify_matrix_sizes(SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE     )

		if cols[0] != rows[1]:
				SCREAMING_SNAKE_CASE_						:str										=      (
				    'Cannot multiply matrix of dimensions '
				    F'({rows[0]},{cols[0]}) and ({rows[1]},{cols[1]})'
				)
				raise ValueError(SCREAMING_SNAKE_CASE     )
		return [
		    [sum(m * n for m, n in zip(SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE     )     ) for j in zip(*SCREAMING_SNAKE_CASE     )] for i in matrix_a
		]







def  SCREAMING_SNAKE_CASE__ (				SCREAMING_SNAKE_CASE     ):
		SCREAMING_SNAKE_CASE_						:Dict										=      int(SCREAMING_SNAKE_CASE     )
		return [[int(row == column     ) for column in range(SCREAMING_SNAKE_CASE     )] for row in range(SCREAMING_SNAKE_CASE     )]







def  SCREAMING_SNAKE_CASE__ (				SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE = True     ):
		if _check_not_integer(SCREAMING_SNAKE_CASE     ):
				if return_map:
						return map(SCREAMING_SNAKE_CASE ,		zip(*SCREAMING_SNAKE_CASE     )     )
				else:
						return list(map(SCREAMING_SNAKE_CASE ,		zip(*SCREAMING_SNAKE_CASE     )     )     )
		raise TypeError('Expected a matrix, got int/list instead'     )







def  SCREAMING_SNAKE_CASE__ (				SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE     ):
		SCREAMING_SNAKE_CASE_						:Any										=      matrix[:row] + matrix[row + 1 :]
		return [row[:column] + row[column + 1 :] for row in minor]







def  SCREAMING_SNAKE_CASE__ (				SCREAMING_SNAKE_CASE     ):
		if len(SCREAMING_SNAKE_CASE     ) == 1:
				return matrix[0][0]

		return sum(
		    x * determinant(minor(SCREAMING_SNAKE_CASE ,		0 ,		SCREAMING_SNAKE_CASE     )     ) * (-1) ** i
		    for i, x in enumerate(matrix[0]     )     )







def  SCREAMING_SNAKE_CASE__ (				SCREAMING_SNAKE_CASE     ):
		SCREAMING_SNAKE_CASE_						:int										=      determinant(SCREAMING_SNAKE_CASE     )
		if det == 0:
				return None

		SCREAMING_SNAKE_CASE_						:int										=      [
		    [determinant(minor(SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE     )     ) for j in range(len(SCREAMING_SNAKE_CASE     )     )]
		    for i in range(len(SCREAMING_SNAKE_CASE     )     )
		]

		SCREAMING_SNAKE_CASE_						:Optional[Any]										=      [
		    [x * (-1) ** (row + col) for col, x in enumerate(matrix_minor[row]     )]
		    for row in range(len(SCREAMING_SNAKE_CASE     )     )
		]
		SCREAMING_SNAKE_CASE_						:int										=      list(transpose(SCREAMING_SNAKE_CASE     )     )
		return scalar_multiply(SCREAMING_SNAKE_CASE ,		1 / det     )







def  SCREAMING_SNAKE_CASE__ (				SCREAMING_SNAKE_CASE     ):
		return not isinstance(SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE     ) and not isinstance(matrix[0] ,		SCREAMING_SNAKE_CASE     )







def  SCREAMING_SNAKE_CASE__ (				SCREAMING_SNAKE_CASE     ):
		return len(SCREAMING_SNAKE_CASE     ), len(matrix[0]     )







def  SCREAMING_SNAKE_CASE__ (				SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE     ):
		SCREAMING_SNAKE_CASE_						:Tuple										=      _shape(SCREAMING_SNAKE_CASE     ) + _shape(SCREAMING_SNAKE_CASE     )
		if shape[0] != shape[3] or shape[1] != shape[2]:
				SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      (
				    'operands could not be broadcast together with shape '
				    F'({shape[0], shape[1]}), ({shape[2], shape[3]})'
				)
				raise ValueError(SCREAMING_SNAKE_CASE     )
		return (shape[0], shape[2]), (shape[1], shape[3])







def  SCREAMING_SNAKE_CASE__ (				):
		SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      [[12, 10], [3, 9]]
		SCREAMING_SNAKE_CASE_						:Dict										=      [[3, 4], [7, 4]]
		SCREAMING_SNAKE_CASE_						:str										=      [[11, 12, 13, 14], [21, 22, 23, 24], [31, 32, 33, 34], [41, 42, 43, 44]]
		SCREAMING_SNAKE_CASE_						:Any										=      [[3, 0, 2], [2, 0, -2], [0, 1, 1]]
		print(F'Add Operation, {add(SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE     ) = } \n'     )
		print(
		    F'Multiply Operation, {multiply(SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE     ) = } \n' ,		)
		print(F'Identity: {identity(5     )}\n'     )
		print(F'Minor of {matrix_c} = {minor(SCREAMING_SNAKE_CASE ,		1 ,		2     )} \n'     )
		print(F'Determinant of {matrix_b} = {determinant(SCREAMING_SNAKE_CASE     )} \n'     )
		print(F'Inverse of {matrix_d} = {inverse(SCREAMING_SNAKE_CASE     )}\n'     )


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							main()





'''simple docstring'''







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

from ...utils import logging


SCREAMING_SNAKE_CASE__     : Optional[int]				=   logging.get_logger(__name__)







def  SCREAMING_SNAKE_CASE__ (				SCREAMING_SNAKE_CASE ,		SCREAMING_SNAKE_CASE     ):
		SCREAMING_SNAKE_CASE_						:List[Any]										=      nn.functional.normalize(SCREAMING_SNAKE_CASE     )
		SCREAMING_SNAKE_CASE_						:str										=      nn.functional.normalize(SCREAMING_SNAKE_CASE     )
		return torch.mm(SCREAMING_SNAKE_CASE ,		normalized_text_embeds.t()     )





class 				__lowerCAmelCase(							lowerCAmelCase__      ):
			__snake_case  :		int		=      CLIPConfig

			__snake_case  :		Optional[Any]		=      ['CLIPEncoderLayer']






			def __init__(   self  :							int      ,       SCREAMING_SNAKE_CASE  :							CLIPConfig	):




					"""simple docstring"""







					super().__init__(SCREAMING_SNAKE_CASE	)

					SCREAMING_SNAKE_CASE_						:List[Any]										=      CLIPVisionModel(config.vision_config	)
					SCREAMING_SNAKE_CASE_						:Dict										=      nn.Linear(config.vision_config.hidden_size      ,       config.projection_dim      ,       bias=SCREAMING_SNAKE_CASE	)

					SCREAMING_SNAKE_CASE_						:List[Any]										=      nn.Parameter(torch.ones(17      ,       config.projection_dim	)      ,       requires_grad=SCREAMING_SNAKE_CASE	)
					SCREAMING_SNAKE_CASE_						:Optional[int]										=      nn.Parameter(torch.ones(3      ,       config.projection_dim	)      ,       requires_grad=SCREAMING_SNAKE_CASE	)

					SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      nn.Parameter(torch.ones(17	)      ,       requires_grad=SCREAMING_SNAKE_CASE	)
					SCREAMING_SNAKE_CASE_						:str										=      nn.Parameter(torch.ones(3	)      ,       requires_grad=SCREAMING_SNAKE_CASE	)






			@torch.no_grad()
			def 				_lowercase	(   self  :							Tuple      ,       SCREAMING_SNAKE_CASE  :							Tuple      ,       SCREAMING_SNAKE_CASE  :							Tuple	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:Optional[int]										=      self.vision_model(SCREAMING_SNAKE_CASE	)[1]  # pooled_output
					SCREAMING_SNAKE_CASE_						:Dict										=      self.visual_projection(SCREAMING_SNAKE_CASE	)

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

					SCREAMING_SNAKE_CASE_						:str										=      []
					SCREAMING_SNAKE_CASE_						:Optional[Any]										=      image_embeds.shape[0]
					for i in range(SCREAMING_SNAKE_CASE	):
							SCREAMING_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
							SCREAMING_SNAKE_CASE_						:Optional[int]										=      0.0

							for concept_idx in range(len(special_cos_dist[0]	)	):
									SCREAMING_SNAKE_CASE_						:Dict										=      special_cos_dist[i][concept_idx]
									SCREAMING_SNAKE_CASE_						:Tuple										=      self.special_care_embeds_weights[concept_idx].item()
									SCREAMING_SNAKE_CASE_						:Any										=      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]}	)
											SCREAMING_SNAKE_CASE_						:Union[str, Any]										=      0.01

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

							result.append(SCREAMING_SNAKE_CASE	)

					SCREAMING_SNAKE_CASE_						:Any										=      [len(res['bad_concepts']	) > 0 for res in result]

					for idx, has_nsfw_concept in enumerate(SCREAMING_SNAKE_CASE	):
							if has_nsfw_concept:
									if torch.is_tensor(SCREAMING_SNAKE_CASE	) or torch.is_tensor(images[0]	):
											SCREAMING_SNAKE_CASE_						:Tuple										=      torch.zeros_like(images[idx]	)  # black image
									else:
											SCREAMING_SNAKE_CASE_						:str										=      np.zeros(images[idx].shape	)  # black image

					if any(SCREAMING_SNAKE_CASE	):
							logger.warning(
							    'Potential NSFW content was detected in one or more images. A black image will be returned instead.'
							    ' Try again with a different prompt and/or seed.'	)

					return images, has_nsfw_concepts






			@torch.no_grad()
			def 				_lowercase	(   self  :							str      ,       SCREAMING_SNAKE_CASE  :							torch.FloatTensor      ,       SCREAMING_SNAKE_CASE  :							torch.FloatTensor	):




					"""simple docstring"""







					SCREAMING_SNAKE_CASE_						:Tuple										=      self.vision_model(SCREAMING_SNAKE_CASE	)[1]  # pooled_output
					SCREAMING_SNAKE_CASE_						:Tuple										=      self.visual_projection(SCREAMING_SNAKE_CASE	)

					SCREAMING_SNAKE_CASE_						:List[str]										=      cosine_distance(SCREAMING_SNAKE_CASE      ,       self.special_care_embeds	)
					SCREAMING_SNAKE_CASE_						:int										=      cosine_distance(SCREAMING_SNAKE_CASE      ,       self.concept_embeds	)

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

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

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

					SCREAMING_SNAKE_CASE_						:Optional[int]										=      0.0  # black image

					return images, has_nsfw_concepts
