


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 							__lowercase     (				__lowerCAmelCase							:       Any      ,					__lowerCAmelCase							:       int      ,					__lowerCAmelCase							:       List[Any]=1E-1_2     ):
							a__    =  jnp.divide(emb_a.T      ,					jnp.clip(jnp.linalg.norm(__lowerCAmelCase      ,					axis=1     )      ,					a_min=__lowerCAmelCase     )     ).T
							a__    =  jnp.divide(emb_a.T      ,					jnp.clip(jnp.linalg.norm(__lowerCAmelCase      ,					axis=1     )      ,					a_min=__lowerCAmelCase     )     ).T
							return jnp.matmul(__lowerCAmelCase      ,					norm_emb_a.T     )







class  snake_case_     (nn.Module   ):
					UpperCAmelCase__      :					CLIPConfig
					UpperCAmelCase__      :					jnp.dtype					   =    jnp.floataa
					def 				lowerCamelCase__(   self     :str   )      ->					Optional[int]:
												a__    =  FlaxCLIPVisionModule(self.config.vision_config   )
												a__    =  nn.Dense(self.config.projection_dim    ,use_bias=__snake_case    ,dtype=self.dtype   )

												a__    =  self.param('concept_embeds'    ,jax.nn.initializers.ones    ,(17, self.config.projection_dim)   )
												a__    =  self.param(
												    'special_care_embeds'    ,jax.nn.initializers.ones    ,(3, self.config.projection_dim)   )

												a__    =  self.param('concept_embeds_weights'    ,jax.nn.initializers.ones    ,(17,)   )
												a__    =  self.param('special_care_embeds_weights'    ,jax.nn.initializers.ones    ,(3,)   )



					def __call__(   self     :Optional[Any]    ,__snake_case     :List[str]   )      ->					Dict:
												a__    =  self.vision_model(__snake_case   )[1]
												a__    =  self.visual_projection(__snake_case   )

												a__    =  jax_cosine_distance(__snake_case    ,self.special_care_embeds   )
												a__    =  jax_cosine_distance(__snake_case    ,self.concept_embeds   )

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

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

												a__    =  cos_dist - self.concept_embeds_weights[None, :] + special_adjustment
												a__    =  jnp.round(__snake_case    ,3   )
												a__    =  jnp.any(concept_scores > 0    ,axis=1   )

												return has_nsfw_concepts







class  snake_case_     (lowerCamelCase_   ):
					UpperCAmelCase__      :					Union[str, Any]					   =    CLIPConfig
					UpperCAmelCase__      :					Tuple					   =    '''clip_input'''
					UpperCAmelCase__      :					List[Any]					   =    FlaxStableDiffusionSafetyCheckerModule
					def __init__(   self     :List[Any]    ,__snake_case     :CLIPConfig    ,__snake_case     :Optional[Tuple] = None    ,__snake_case     :int = 0    ,__snake_case     :jnp.dtype = jnp.floataa    ,__snake_case     :bool = True    ,**__snake_case     :int    ,)      ->					List[str]:
												if input_shape is None:
																			a__    =  (1, 2_24, 2_24, 3)
												a__    =  self.module_class(config=__snake_case    ,dtype=__snake_case    ,**__snake_case   )
												super().__init__(__snake_case    ,__snake_case    ,input_shape=__snake_case    ,seed=__snake_case    ,dtype=__snake_case    ,_do_init=_do_init   )
					def 				lowerCamelCase__(   self     :Union[str, Any]    ,__snake_case     :jax.random.KeyArray    ,__snake_case     :Tuple    ,__snake_case     :FrozenDict = None   )      ->					FrozenDict:
												# init input tensor
												a__    =  jax.random.normal(__snake_case    ,__snake_case   )

												a__   ,      a__    =  jax.random.split(__snake_case   )
												a__    =  {'params': params_rng, 'dropout': dropout_rng}

												a__    =  self.module.init(__snake_case    ,__snake_case   )['params']

												return random_params



					def __call__(   self     :List[Any]    ,__snake_case     :int    ,__snake_case     :dict = None    ,)      ->					List[Any]:
												a__    =  jnp.transpose(__snake_case    ,(0, 2, 3, 1)   )

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








from manim import *







class  snake_case_     (lowerCamelCase_   ):
					def 				lowerCamelCase__(   self     :Optional[Any]   )      ->					Optional[int]:
												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(*__snake_case   ).arrange(__snake_case    ,buff=0   )
												a__    =  VGroup(*__snake_case   ).arrange(__snake_case    ,buff=0   )
												a__    =  VGroup(__snake_case    ,__snake_case   ).arrange(__snake_case    ,buff=0   )
												a__    =  Text('CPU'    ,font_size=24   )
												a__    =  Group(__snake_case    ,__snake_case   ).arrange(__snake_case    ,buff=0.5    ,aligned_edge=__snake_case   )
												cpu.move_to([-2.5, -0.5, 0]   )
												self.add(__snake_case   )

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

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

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

												a__    =  []
												a__    =  []

												for i, rect in enumerate(__snake_case   ):
																			a__    =  fill.copy().set_fill(__snake_case    ,opacity=0.8   )
																			target.move_to(__snake_case   )
																			model_arr.append(__snake_case   )

																			a__    =  Rectangle(height=0.46    ,width=0.46   ).set_stroke(width=0.0   ).set_fill(__snake_case    ,opacity=0.8   )
																			cpu_target.move_to(cpu_left_col_base[i]   )
																			model_cpu_arr.append(__snake_case   )

												self.add(*__snake_case    ,*__snake_case   )

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

												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(__snake_case    ,__snake_case   )

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

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

												a__    =  MarkupText(
												    F'Now watch as an input is passed through the model\nand how the memory is utilized and handled.'    ,font_size=24    ,)
												step_a.move_to([2, 2, 0]   )

												self.play(Write(__snake_case   )   )

												a__    =  Square(0.3   )
												input.set_fill(__snake_case    ,opacity=1.0   )
												input.set_stroke(width=0.0   )
												input.next_to(model_base[0]    ,__snake_case    ,buff=0.5   )

												self.play(Write(__snake_case   )   )

												input.generate_target()
												input.target.next_to(model_arr[0]    ,direction=__snake_case    ,buff=0.02   )
												self.play(MoveToTarget(__snake_case   )   )

												self.play(FadeOut(__snake_case   )   )

												a__    =  Arrow(start=__snake_case    ,end=__snake_case    ,color=__snake_case    ,buff=0.5   )
												a.next_to(model_arr[0].get_left()    ,__snake_case    ,buff=0.2   )

												model_cpu_arr[0].generate_target()
												model_cpu_arr[0].target.move_to(gpu_rect[0]   )

												a__    =  MarkupText(
												    F'As the input reaches a layer, the hook triggers\nand weights are moved from the CPU\nto the GPU and back.'    ,font_size=24    ,)
												step_a.move_to([2, 2, 0]   )

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

												a__    =  {'run_time': 1, 'fade_in': True, 'fade_out': True, 'buff': 0.02}

												self.play(
												    Write(__snake_case   )    ,Circumscribe(model_arr[0]    ,color=__snake_case    ,**__snake_case   )    ,Circumscribe(model_cpu_arr[0]    ,color=__snake_case    ,**__snake_case   )    ,Circumscribe(gpu_rect[0]    ,color=__snake_case    ,**__snake_case   )    ,)
												self.play(MoveToTarget(model_cpu_arr[0]   )   )

												a__    =  a.copy()
												for i in range(6   ):
																			a_c.next_to(model_arr[i].get_right() + 0.02    ,__snake_case    ,buff=0.2   )

																			input.generate_target()
																			input.target.move_to(model_arr[i].get_right() + 0.02   )

																			a__    =  AnimationGroup(
																			    FadeOut(__snake_case    ,run_time=0.5   )    ,MoveToTarget(__snake_case    ,run_time=0.5   )    ,FadeIn(__snake_case    ,run_time=0.5   )    ,lag_ratio=0.2   )

																			self.play(__snake_case   )

																			model_cpu_arr[i].generate_target()
																			model_cpu_arr[i].target.move_to(cpu_left_col_base[i]   )

																			if i < 5:
																										model_cpu_arr[i + 1].generate_target()
																										model_cpu_arr[i + 1].target.move_to(gpu_rect[0]   )
																										if i >= 1:
																																	a__    =  0.7

																										self.play(
																										    Circumscribe(model_arr[i]    ,**__snake_case   )    ,Circumscribe(cpu_left_col_base[i]    ,**__snake_case   )    ,Circumscribe(cpu_left_col_base[i + 1]    ,color=__snake_case    ,**__snake_case   )    ,Circumscribe(gpu_rect[0]    ,color=__snake_case    ,**__snake_case   )    ,Circumscribe(model_arr[i + 1]    ,color=__snake_case    ,**__snake_case   )    ,)
																										if i < 1:
																																	self.play(
																																	    MoveToTarget(model_cpu_arr[i]   )    ,MoveToTarget(model_cpu_arr[i + 1]   )    ,)
																										else:
																																	self.play(
																																	    MoveToTarget(model_cpu_arr[i]    ,run_time=0.7   )    ,MoveToTarget(model_cpu_arr[i + 1]    ,run_time=0.7   )    ,)
																			else:
																										model_cpu_arr[i].generate_target()
																										model_cpu_arr[i].target.move_to(cpu_left_col_base[-1]   )
																										input.generate_target()
																										input.target.next_to(model_arr[-1].get_right()    ,RIGHT + 0.02    ,buff=0.2   )

																										self.play(
																										    Circumscribe(model_arr[-1]    ,color=__snake_case    ,**__snake_case   )    ,Circumscribe(cpu_left_col_base[-1]    ,color=__snake_case    ,**__snake_case   )    ,Circumscribe(gpu_rect[0]    ,color=__snake_case    ,**__snake_case   )    ,)

																										self.play(MoveToTarget(model_cpu_arr[i]   )   )

																			a__    =  a_c
																			a__    =  a_c.copy()

												input.generate_target()
												input.target.next_to(model_base[-1]    ,RIGHT + 0.02    ,buff=0.5   )
												self.play(
												    FadeOut(__snake_case   )    ,FadeOut(__snake_case    ,run_time=0.5   )    ,)

												a__    =  MarkupText(F'Inference on a model too large for GPU memory\nis successfully completed.'    ,font_size=24   )
												step_a.move_to([2, 2, 0]   )

												self.play(Write(__snake_case    ,run_time=3   )    ,MoveToTarget(__snake_case   )   )

												self.wait()




