


"""simple docstring"""






from manim import *


class      __lowerCamelCase	(       a__					):

     '''simple docstring'''


     def 				_UpperCAmelCase   (   self				)							->				Dict:
          _a     						=					Rectangle(height=0.5     ,					width=0.5				)
          _a     						=					Rectangle(height=0.46     ,					width=0.46				).set_stroke(width=0				)
          _a     						=					Rectangle(height=0.25     ,					width=0.25				)

          _a     						=					[mem.copy() for i in range(6				)]
          _a     						=					[mem.copy() for i in range(6				)]
          _a     						=					VGroup(*__UpperCAmelCase				).arrange(__UpperCAmelCase     ,					buff=0				)
          _a     						=					VGroup(*__UpperCAmelCase				).arrange(__UpperCAmelCase     ,					buff=0				)
          _a     						=					VGroup(__UpperCAmelCase     ,					__UpperCAmelCase				).arrange(__UpperCAmelCase     ,					buff=0				)
          _a     						=					Text('''CPU'''     ,					font_size=24				)
          _a     						=					Group(__UpperCAmelCase     ,					__UpperCAmelCase				).arrange(__UpperCAmelCase     ,					buff=0.5     ,					aligned_edge=__UpperCAmelCase				)
          cpu.move_to([-2.5, -0.5, 0]				)
          self.add(__UpperCAmelCase				)

          _a     						=					[mem.copy() for i in range(4				)]
          _a     						=					VGroup(*__UpperCAmelCase				).arrange(__UpperCAmelCase     ,					buff=0				)
          _a     						=					Text('''GPU'''     ,					font_size=24				)
          _a     						=					Group(__UpperCAmelCase     ,					__UpperCAmelCase				).arrange(__UpperCAmelCase     ,					buff=0.5     ,					aligned_edge=__UpperCAmelCase				)
          gpu.move_to([-1, -1, 0]				)
          self.add(__UpperCAmelCase				)

          _a     						=					[mem.copy() for i in range(6				)]
          _a     						=					VGroup(*__UpperCAmelCase				).arrange(__UpperCAmelCase     ,					buff=0				)

          _a     						=					Text('''Model'''     ,					font_size=24				)
          _a     						=					Group(__UpperCAmelCase     ,					__UpperCAmelCase				).arrange(__UpperCAmelCase     ,					buff=0.5     ,					aligned_edge=__UpperCAmelCase				)
          model.move_to([3, -1.0, 0]				)
          self.add(__UpperCAmelCase				)

          _a     						=					[]
          _a     						=					[]

          for i, rect in enumerate(__UpperCAmelCase				):
               rect.set_stroke(__UpperCAmelCase				)

               _a     						=					Rectangle(height=0.46 / 4     ,					width=0.46 / 3				).set_stroke(width=0.0				).set_fill(__UpperCAmelCase     ,					opacity=0.7				)

               if i == 0:
                    cpu_target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT				)     ,					buff=0.02     ,					direction=__UpperCAmelCase				)
                    cpu_target.set_x(cpu_target.get_x() + 0.1				)
               elif i == 3:
                    cpu_target.next_to(model_cpu_arr[0]     ,					direction=__UpperCAmelCase     ,					buff=0.0				)
               else:
                    cpu_target.next_to(model_cpu_arr[i - 1]     ,					direction=__UpperCAmelCase     ,					buff=0.0				)
               self.add(__UpperCAmelCase				)
               model_cpu_arr.append(__UpperCAmelCase				)

          self.add(*__UpperCAmelCase     ,					*__UpperCAmelCase				)

          _a     						=					[meta_mem.copy() for i in range(6				)]
          _a     						=					[meta_mem.copy() for i in range(6				)]
          _a     						=					VGroup(*__UpperCAmelCase				).arrange(__UpperCAmelCase     ,					buff=0				)
          _a     						=					VGroup(*__UpperCAmelCase				).arrange(__UpperCAmelCase     ,					buff=0				)
          _a     						=					VGroup(__UpperCAmelCase     ,					__UpperCAmelCase				).arrange(__UpperCAmelCase     ,					buff=0				)
          _a     						=					Text('''Disk'''     ,					font_size=24				)
          _a     						=					Group(__UpperCAmelCase     ,					__UpperCAmelCase				).arrange(__UpperCAmelCase     ,					buff=0.5     ,					aligned_edge=__UpperCAmelCase				)
          disk.move_to([-4.0, -1.25, 0]				)
          self.add(__UpperCAmelCase     ,					__UpperCAmelCase				)

          _a     						=					[]

          for i in range(6				):
               _a     						=					fill.copy().set_fill(__UpperCAmelCase     ,					opacity=0.8				)
               target.move_to(disk_left_col_base[i]				).scale(0.5				)
               cpu_disk_arr.append(__UpperCAmelCase				)

          self.add(*__UpperCAmelCase				)

          _a     						=					Square(side_length=2.2				)
          key.move_to([-5, 2, 0]				)

          _a     						=					MarkupText(
              F'<b>Key:</b>\n\n<span fgcolor=\'{YELLOW}\'>●</span> Empty Model'     ,					font_size=18     ,					)

          key_text.move_to([-5, 2.4, 0]				)

          self.add(__UpperCAmelCase     ,					__UpperCAmelCase				)

          _a     						=					MarkupText(
              F'<span fgcolor=\'{BLUE}\'>●</span> Checkpoint'     ,					font_size=18     ,					)

          blue_text.next_to(__UpperCAmelCase     ,					DOWN * 2.4     ,					aligned_edge=key_text.get_left()				)
          self.add(__UpperCAmelCase				)

          _a     						=					MarkupText(F'The offloaded weights are all sent to the CPU.'     ,					font_size=24				)
          step_a.move_to([2, 2, 0]				)

          self.play(Write(__UpperCAmelCase     ,					run_time=3				)				)

          for i in range(6				):
               _a     						=					cpu_disk_arr[i]
               _a     						=					rect.copy().set_fill(__UpperCAmelCase     ,					opacity=0.8				).scale(2.0				)
               cpa.generate_target()
               cpa.target.move_to(model_base[i]				)

               if i == 0:
                    rect.set_fill(__UpperCAmelCase     ,					opacity=0.8				)
                    rect.generate_target()
                    rect.target.move_to(cpu_left_col_base[0]				).scale(2.0				)

                    self.remove(
                        *__UpperCAmelCase     ,					*__UpperCAmelCase     ,					)

               else:
                    rect.generate_target()
                    rect.target.move_to(cpu_left_col_base[i]				).scale(2.0				)
               self.play(MoveToTarget(__UpperCAmelCase				)     ,					MoveToTarget(__UpperCAmelCase				)     ,					model_base[i].animate.set_stroke(__UpperCAmelCase				)				)
          self.play(FadeOut(__UpperCAmelCase				)				)

          _a     						=					MarkupText(
              F'Finally, hooks are added to each weight in the model\nto transfer the weights from CPU to GPU\n\t\tand back when needed.'     ,					font_size=24     ,					)
          step_a.move_to([2, 2, 0]				)

          self.play(Write(__UpperCAmelCase     ,					run_time=3				)				)

          _a     						=					[]
          _a     						=					[]
          for i in range(6				):
               _a     						=					Arrow(start=__UpperCAmelCase     ,					end=__UpperCAmelCase     ,					color=__UpperCAmelCase     ,					buff=0.5				)
               a.next_to(model_base[i].get_left()     ,					__UpperCAmelCase     ,					buff=0.2				)
               arrows.append(__UpperCAmelCase				)
               animations.append(Write(__UpperCAmelCase				)				)
          self.play(*__UpperCAmelCase				)
          self.wait()



"""simple docstring"""






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

from ...utils import logging


__snake_case												=							logging.get_logger(__name__)
def    A_ ( _lowerCAmelCase  :       Optional[int],  _lowerCAmelCase  :       Optional[Any]							):






     """simple docstring"""

     _a     						=					nn.functional.normalize(_lowerCAmelCase							)
     _a     						=					nn.functional.normalize(_lowerCAmelCase							)
     return torch.mm(_lowerCAmelCase,  normalized_text_embeds.t()							)


class      __lowerCamelCase	(       a__					):

     '''simple docstring'''
     A_							:						str     =		CLIPConfig

     A_							:						List[str]     =		['CLIPEncoderLayer']


     def __init__(   self     ,					__UpperCAmelCase				)							->				List[Any]:
          super().__init__(__UpperCAmelCase				)

          _a     						=					CLIPVisionModel(config.vision_config				)
          _a     						=					nn.Linear(config.vision_config.hidden_size     ,					config.projection_dim     ,					bias=__UpperCAmelCase				)

          _a     						=					nn.Parameter(torch.ones(17     ,					config.projection_dim				)     ,					requires_grad=__UpperCAmelCase				)
          _a     						=					nn.Parameter(torch.ones(3     ,					config.projection_dim				)     ,					requires_grad=__UpperCAmelCase				)

          _a     						=					nn.Parameter(torch.ones(17				)     ,					requires_grad=__UpperCAmelCase				)
          _a     						=					nn.Parameter(torch.ones(3				)     ,					requires_grad=__UpperCAmelCase				)


     @torch.no_grad()
     def 				_UpperCAmelCase   (   self     ,					__UpperCAmelCase     ,					__UpperCAmelCase				)							->				Optional[Any]:
          _a     						=					self.vision_model(__UpperCAmelCase				)[1]  # pooled_output
          _a     						=					self.visual_projection(__UpperCAmelCase				)

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

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

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

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

               result.append(__UpperCAmelCase				)

          _a     						=					[len(res['''bad_concepts''']				) > 0 for res in result]

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

          if any(__UpperCAmelCase				):
               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 				_UpperCAmelCase   (   self     ,					__UpperCAmelCase     ,					__UpperCAmelCase				)							->				Any:
          _a     						=					self.vision_model(__UpperCAmelCase				)[1]  # pooled_output
          _a     						=					self.visual_projection(__UpperCAmelCase				)

          _a     						=					cosine_distance(__UpperCAmelCase     ,					self.special_care_embeds				)
          _a     						=					cosine_distance(__UpperCAmelCase     ,					self.concept_embeds				)

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

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

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

          _a     						=					0.0  # black image

          return images, has_nsfw_concepts