



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

from ...utils import logging


UpperCAmelCase :				Any							=logging.get_logger(__name__)



def  _lowerCAmelCase     (_lowerCAmelCase ,						_lowerCAmelCase):
					UpperCamelCase_			= nn.functional.normalize(_lowerCAmelCase)
					UpperCamelCase_			= nn.functional.normalize(_lowerCAmelCase)
					return torch.mm(_lowerCAmelCase ,						normalized_text_embeds.t())






class    _lowercase (a_   ):
				'''simple docstring'''







				lowercase__     =    CLIPConfig

				lowercase__     =    ["""CLIPEncoderLayer"""]

				def __init__(			self  ,			snake_case__     ):

									'''simple docstring'''


									super().__init__(snake_case__     )

									UpperCamelCase_			= CLIPVisionModel(config.vision_config     )
									UpperCamelCase_			= nn.Linear(config.vision_config.hidden_size  ,			config.projection_dim  ,			bias=snake_case__     )

									UpperCamelCase_			= nn.Parameter(torch.ones(17  ,			config.projection_dim     )  ,			requires_grad=snake_case__     )
									UpperCamelCase_			= nn.Parameter(torch.ones(3  ,			config.projection_dim     )  ,			requires_grad=snake_case__     )

									UpperCamelCase_			= nn.Parameter(torch.ones(17     )  ,			requires_grad=snake_case__     )
									UpperCamelCase_			= nn.Parameter(torch.ones(3     )  ,			requires_grad=snake_case__     )

				@torch.no_grad()
				def    _lowerCamelCase       (			self  ,			snake_case__  ,			snake_case__     ):

									'''simple docstring'''


									UpperCamelCase_			= self.vision_model(snake_case__     )[1]  # pooled_output
									UpperCamelCase_			= self.visual_projection(snake_case__     )

									# we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
									UpperCamelCase_			= cosine_distance(snake_case__  ,			self.special_care_embeds     ).cpu().float().numpy()
									UpperCamelCase_			= cosine_distance(snake_case__  ,			self.concept_embeds     ).cpu().float().numpy()

									UpperCamelCase_			= []
									UpperCamelCase_			= image_embeds.shape[0]
									for i in range(snake_case__     ):
														UpperCamelCase_			= {"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
														UpperCamelCase_			= 0.0

														for concept_idx in range(len(special_cos_dist[0]     )     ):
																			UpperCamelCase_			= special_cos_dist[i][concept_idx]
																			UpperCamelCase_			= self.special_care_embeds_weights[concept_idx].item()
																			UpperCamelCase_			= 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]}     )
																								UpperCamelCase_			= 0.01

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

														result.append(snake_case__     )

									UpperCamelCase_			= [len(res["bad_concepts"]     ) > 0 for res in result]

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

									if any(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    _lowerCamelCase       (			self  ,			snake_case__  ,			snake_case__     ):

									'''simple docstring'''


									UpperCamelCase_			= self.vision_model(snake_case__     )[1]  # pooled_output
									UpperCamelCase_			= self.visual_projection(snake_case__     )

									UpperCamelCase_			= cosine_distance(snake_case__  ,			self.special_care_embeds     )
									UpperCamelCase_			= cosine_distance(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
									UpperCamelCase_			= 0.0

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

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

									UpperCamelCase_			= 0.0  # black image

									return images, has_nsfw_concepts








"""simple docstring"""





UpperCamelCase					=     float("""inf""")







class 						_a  :





   '''simple docstring'''






   def __init__(       self					, UpperCAmelCase_)			->   List[str]:




          '''simple docstring'''




          lowercase__:							Optional[Any]         =     [0] * n
          lowercase__:							Dict         =     [0] * n
          lowercase__:							List[Any]         =     [0] * n
          lowercase__:							str         =     [[] for _ in range(UpperCAmelCase_)]





   def __lowercase							(       self					, UpperCAmelCase_					, UpperCAmelCase_					, UpperCAmelCase_					, UpperCAmelCase_=0)			->   Optional[int]:




          '''simple docstring'''




          self.adj[a].append([b, len(self.adj[b]), c, 0])
          self.adj[b].append([a, len(self.adj[a]) - 1, rcap, 0])





   def __lowercase							(       self					, UpperCAmelCase_					, UpperCAmelCase_					, UpperCAmelCase_)			->   Union[str, Any]:




          '''simple docstring'''




          if vertex == sink or not flow:
                 return flow

          for i in range(self.ptr[vertex]					, len(self.adj[vertex])):
                 lowercase__:							Optional[Any]         =     self.adj[vertex][i]
                 if self.lvl[e[0]] == self.lvl[vertex] + 1:
                        lowercase__:							Optional[int]         =     self.depth_first_search(e[0]					, UpperCAmelCase_					, min(UpperCAmelCase_					, e[2] - e[3]))
                        if p:
                               self.adj[vertex][i][3] += p
                               self.adj[e[0]][e[1]][3] -= p
                               return p
                 lowercase__:							int         =     self.ptr[vertex] + 1
          return 0





   def __lowercase							(       self					, UpperCAmelCase_					, UpperCAmelCase_)			->   str:




          '''simple docstring'''




          lowercase__    ,      lowercase__:							Union[str, Any]         =     0, source
          for l in range(31):  # noqa: E741  l = 30 maybe faster for random data
                 while True:
                        lowercase__    ,      lowercase__:							Union[str, Any]         =     [0] * len(self.q), [0] * len(self.q)
                        lowercase__    ,      lowercase__    ,      lowercase__:							str         =     0, 1, 1
                        while qi < qe and not self.lvl[sink]:
                               lowercase__:							Tuple         =     self.q[qi]
                               qi += 1
                               for e in self.adj[v]:
                                      if not self.lvl[e[0]] and (e[2] - e[3]) >> (30 - l):
                                             lowercase__:							Optional[int]         =     e[0]
                                             qe += 1
                                             lowercase__:							str         =     self.lvl[v] + 1

                        lowercase__:							List[str]         =     self.depth_first_search(UpperCAmelCase_					, UpperCAmelCase_					, UpperCAmelCase_)
                        while p:
                               flow += p
                               lowercase__:							Any         =     self.depth_first_search(UpperCAmelCase_					, UpperCAmelCase_					, UpperCAmelCase_)

                        if not self.lvl[sink]:
                               break

          return flow
UpperCamelCase					=     Dinic(10)
UpperCamelCase					=     0
UpperCamelCase					=     9
for vertex in range(1, 5):
  graph.add_edge(source, vertex, 1)
for vertex in range(5, 9):
  graph.add_edge(vertex, sink, 1)
for vertex in range(1, 5):
  graph.add_edge(vertex, vertex + 4, 1)

# Now we can know that is the maximum flow(source -> sink)
print(graph.max_flow(source, sink))






