





from manim import *



class       A__     ( __snake_case    ):





      def  __UpperCamelCase(				self     ):
       '''simple docstring'''




       UpperCamelCase			:      Optional[int] 			=     Rectangle(height=0.5 ,							width=0.5     )
       UpperCamelCase			:      str 			=     Rectangle(height=0.25 ,							width=0.25     )
       UpperCamelCase			:      Optional[Any] 			=     Rectangle(height=0.46 ,							width=0.46     ).set_stroke(width=0     )

       UpperCamelCase			:      Optional[Any] 			=     [mem.copy() for i in range(6     )]
       UpperCamelCase			:      List[str] 			=     [mem.copy() for i in range(6     )]
       UpperCamelCase			:      int 			=     VGroup(*A_     ).arrange(A_ ,							buff=0     )
       UpperCamelCase			:      Tuple 			=     VGroup(*A_     ).arrange(A_ ,							buff=0     )
       UpperCamelCase			:      Union[str, Any] 			=     VGroup(A_ ,							A_     ).arrange(A_ ,							buff=0     )
       UpperCamelCase			:      Optional[int] 			=     Text("CPU" ,							font_size=24     )
       UpperCamelCase			:      List[Any] 			=     Group(A_ ,							A_     ).arrange(A_ ,							buff=0.5 ,							aligned_edge=A_     )
       cpu.move_to([-2.5, -0.5, 0]     )
       self.add(A_     )

       UpperCamelCase			:      List[Any] 			=     [mem.copy() for i in range(4     )]
       UpperCamelCase			:      List[Any] 			=     VGroup(*A_     ).arrange(A_ ,							buff=0     )
       UpperCamelCase			:      Optional[Any] 			=     Text("GPU" ,							font_size=24     )
       UpperCamelCase			:      List[str] 			=     Group(A_ ,							A_     ).arrange(A_ ,							buff=0.5 ,							aligned_edge=A_     )
       gpu.move_to([-1, -1, 0]     )
       self.add(A_     )

       UpperCamelCase			:      Any 			=     [mem.copy() for i in range(6     )]
       UpperCamelCase			:      Any 			=     VGroup(*A_     ).arrange(A_ ,							buff=0     )

       UpperCamelCase			:      Optional[Any] 			=     Text("Model" ,							font_size=24     )
       UpperCamelCase			:      List[Any] 			=     Group(A_ ,							A_     ).arrange(A_ ,							buff=0.5 ,							aligned_edge=A_     )
       model.move_to([3, -1.0, 0]     )
       self.add(A_     )

       UpperCamelCase			:      Dict 			=     []
       UpperCamelCase			:      int 			=     []
       UpperCamelCase			:      Tuple 			=     []

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

        UpperCamelCase			:      Optional[Any] 			=     Rectangle(height=0.46 / 4 ,							width=0.46 / 3     ).set_stroke(width=0.0     ).set_fill(A_ ,							opacity=0.7     )

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

       self.add(*A_ ,							*A_ ,							*A_     )

       UpperCamelCase			:      Any 			=     [mem.copy() for i in range(6     )]
       UpperCamelCase			:      List[str] 			=     VGroup(*A_     ).arrange(A_ ,							buff=0     )

       UpperCamelCase			:      Dict 			=     Text("Loaded Checkpoint" ,							font_size=24     )
       UpperCamelCase			:      Union[str, Any] 			=     Group(A_ ,							A_     ).arrange(A_ ,							buff=0.5 ,							aligned_edge=A_     )
       checkpoint.move_to([3, 0.5, 0]     )

       self.add(A_     )

       UpperCamelCase			:      int 			=     []
       UpperCamelCase			:      List[Any] 			=     []

       for i, rect in enumerate(A_     ):
        UpperCamelCase			:      int 			=     fill.copy().set_fill(A_ ,							opacity=0.7     )
        target.move_to(A_     )
        ckpt_arr.append(A_     )

        UpperCamelCase			:      Optional[Any] 			=     target.copy()
        if i < 5:
         cpu_target.move_to(cpu_left_col_base[i + 1]     )
        else:
         cpu_target.move_to(cpu_right_col_base[i - 5]     )
        ckpt_cpu_arr.append(A_     )
       self.add(*A_ ,							*A_     )

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

       UpperCamelCase			:      Any 			=     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(A_ ,							A_     )

       UpperCamelCase			:      List[str] 			=     MarkupText(
           F"""<span fgcolor='{BLUE}'>●</span> Checkpoint""" ,							font_size=18 ,							)

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

       UpperCamelCase			:      Optional[int] 			=     MarkupText(
           F"""Based on the passed in configuration, weights are stored in\na variety of np.memmaps on disk or to a particular device.""" ,							font_size=24 ,							)
       step_a.move_to([2, 2, 0]     )

       UpperCamelCase			:      Union[str, Any] 			=     [meta_mem.copy() for i in range(6     )]
       UpperCamelCase			:      List[str] 			=     [meta_mem.copy() for i in range(6     )]
       UpperCamelCase			:      str 			=     VGroup(*A_     ).arrange(A_ ,							buff=0     )
       UpperCamelCase			:      Union[str, Any] 			=     VGroup(*A_     ).arrange(A_ ,							buff=0     )
       UpperCamelCase			:      List[str] 			=     VGroup(A_ ,							A_     ).arrange(A_ ,							buff=0     )
       UpperCamelCase			:      str 			=     Text("Disk" ,							font_size=24     )
       UpperCamelCase			:      int 			=     Group(A_ ,							A_     ).arrange(A_ ,							buff=0.5 ,							aligned_edge=A_     )
       disk.move_to([-4.0, -1.25, 0]     )
       self.play(Write(A_ ,							run_time=3     ) ,							Write(A_ ,							run_time=1     ) ,							Create(A_ ,							run_time=1     )     )

       UpperCamelCase			:      Union[str, Any] 			=     []
       for i, rect in enumerate(A_     ):
        UpperCamelCase			:      List[Any] 			=     rect.copy()
        target.generate_target()
        target.target.move_to(disk_left_col_base[i]     ).scale(0.5     )
        animations.append(MoveToTarget(A_ ,							run_time=1.5     )     )
       self.play(*A_     )

       self.play(FadeOut(A_     )     )

       UpperCamelCase			:      Any 			=     MarkupText(F"""Then, the checkpoint is removed from memory\nthrough garbage collection.""" ,							font_size=24     )
       step_a.move_to([2, 2, 0]     )

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

       self.play(
           FadeOut(A_ ,							A_ ,							*A_ ,							*A_     ) ,							)

       self.wait()







from PIL import Image



def 	A_       (  _lowerCAmelCase  )		->				Image:
 UpperCamelCase			,					UpperCamelCase			:      List[Any] 			=     image.size
 UpperCamelCase			:      Union[str, Any] 			=     0
 UpperCamelCase			:      List[str] 			=     image.load()
 for i in range(_lowerCAmelCase  ):
  for j in range(_lowerCAmelCase  ):
   UpperCamelCase			:      List[Any] 			=     pixels[j, i]
   mean += pixel
 mean //= width * height

 for j in range(_lowerCAmelCase  ):
  for i in range(_lowerCAmelCase  ):
   UpperCamelCase			:      Union[str, Any] 			=     255 if pixels[i, j] > mean else 0
 return image


if __name__ == "__main__":
    __lowerCamelCase :  Union[str, Any]										=  mean_threshold(Image.open("""path_to_image""").convert("""L"""))
    image.save("""output_image_path""")
